Multi-agent systems (MAS) organize multiple specialized AI agents — typically powered by large language models — to collaborate on complex tasks through structured coordination patterns. By 2025, multi-agent architectures have become the dominant approach for building sophisticated AI applications, outperforming single-agent systems in parallel processing, adaptability, and collective reasoning.

A primary agent acts as a hub, decomposing tasks, routing them to specialized workers, and synthesizing results. This hub-and-spoke model ensures consistency and simple debugging, but can bottleneck at 10-20 agents due to coordination overhead and context concentration.

Variants include the Single Agent + Dynamic Routing pattern, where the primary agent invokes specialists via dynamic function calling based on the current task.

Agents collaborate directly without a central authority, enabling flexible local optimizations like negotiation. For example, driver agents might share route information in a delivery system. Peer-to-peer supports emergent behaviors but risks inconsistency without oversight.

A multi-level structure with supervisor agents at the top, domain agents in the middle, and specialists at the bottom. Combines parallel execution, feedback loops, and shared tools/RAG for knowledge access. The control flow follows: decompose, execute parallel subtasks, gather feedback/refine, aggregate results.

Agents can engage in debate by proposing solutions, critiquing peers, and iterating via feedback loops. A voting mechanism selects the best output from multiple candidates. This pattern improves reasoning through diverse perspectives and is often implemented as:

• Multiple agents independently propose solutions
• A critic agent evaluates and scores proposals
• Agents revise based on feedback
• Final selection via majority vote or weighted scoring

The Mixture of Agents approach uses diverse specialist agents to achieve collective intelligence that exceeds any individual agent's capability.

Role-specialized agents (researcher, writer, coder, reviewer) leverage domain expertise while using smaller, more efficient models. Key enablers include:

• Shared Tools/RAG: Centralized access to web search, code execution, and knowledge stores
• State Management: Protocols for context sharing, failure handling, and inter-agent messaging
• Human-in-the-Loop: Oversight for critical decisions and quality assurance
• Memory Systems: Shared and individual memory for context retention

# Supervisor pattern using LangGraph
from langgraph.graph import StateGraph, END
from typing import TypedDict, Literal
 
class TeamState(TypedDict):
    task: str
    research: str
    code: str
    review: str
    status: str
 
def supervisor(state: TeamState) -> TeamState:
    """Supervisor decomposes task and routes to specialists."""
    if not state.get('research'):
        return {**state, 'status': 'needs_research'}
    elif not state.get('code'):
        return {**state, 'status': 'needs_coding'}
    elif not state.get('review'):
        return {**state, 'status': 'needs_review'}
    return {**state, 'status': 'complete'}
 
def researcher(state: TeamState) -> TeamState:
    result = llm.invoke(f"Research: {state['task']}")
    return {**state, 'research': result}
 
def coder(state: TeamState) -> TeamState:
    result = llm.invoke(f"Code solution based on: {state['research']}")
    return {**state, 'code': result}
 
def reviewer(state: TeamState) -> TeamState:
    result = llm.invoke(f"Review code: {state['code']}")
    return {**state, 'review': result}
 
def route(state: TeamState) -> Literal['researcher', 'coder', 'reviewer', '__end__']:
    status = state['status']
    if status == 'needs_research': return 'researcher'
    if status == 'needs_coding': return 'coder'
    if status == 'needs_review': return 'reviewer'
    return '__end__'
 
graph = StateGraph(TeamState)
graph.add_node('supervisor', supervisor)
graph.add_node('researcher', researcher)
graph.add_node('coder', coder)
graph.add_node('reviewer', reviewer)
graph.set_entry_point('supervisor')
graph.add_conditional_edges('supervisor', route)
for node in ['researcher', 'coder', 'reviewer']:
    graph.add_edge(node, 'supervisor')
app = graph.compile()

• CrewAI — Role-based crews with sequential/hierarchical processes
• AutoGen — Conversational multi-agent systems with group chat
• LangGraph — Graph-based stateful agent orchestration with cycles
• OpenAI Agents SDK — Lightweight multi-agent handoffs
• smolagents — Code-first lightweight agents with sub-agent support

• Agents 1.0 vs. 2.0: Version 1.0 uses rigid, predetermined workflows; version 2.0 enables adaptive collaboration and emergent behaviors
• Loop Mechanisms: Iterative refinement cycles within hierarchies improve output quality
• Parallel Execution: Multiple agents processing subtasks simultaneously boosts throughput
• Failure Recovery: Robust error handling and fallback routing prevent cascading failures

• Anthropic — Multi-Agent Research System
• Architectures for Multi-Agent Systems
• Ultimate Guide to AI Agent Architectures 2025
• Multi-Agent Design Patterns (2026)

• CrewAI — CrewAI multi-agent framework
• AutoGen — Microsoft AutoGen/AG2
• LangGraph — LangGraph stateful agent graphs
• A2A Protocol — Agent-to-Agent communication protocol
• Agent Evaluation — Benchmarks for evaluating agents