Multi-Agent Systems

Overview

Multi-agent systems decompose complex tasks across specialized agents: a research agent gathers information, a coding agent writes software, a reviewer agent validates quality, and an orchestrator coordinates workflow. Benefits: (1) Specialization - each agent masters specific skills, (2) Parallel execution - agents work simultaneously, (3) Error correction - agents review each other's work, (4) Scalability - add agents for new capabilities. Frameworks like CrewAI provide role-based agents with tools and memory. LangGraph enables graph-based workflows with cycles for iterative refinement. AutoGen supports conversational agents with human-in-the-loop. Applications: software engineering (Devin, GPT Engineer), research assistants, customer support, business process automation.

Key Frameworks (October 2025)

• LangGraph: Graph-based agent workflows with state management and cycles
• CrewAI: Role-based agents with sequential/hierarchical coordination
• Microsoft AutoGen: Conversational agents with human-in-the-loop
• AutoGPT: Autonomous goal-driven agent with memory and tools
• MetaGPT: Software engineering agents simulating roles (PM, architect, engineer)
• OpenAI Assistants API: Multi-agent orchestration with function calling
• LlamaIndex Workflows: Data-centric multi-agent pipelines
• Semantic Kernel: Microsoft's framework for agent orchestration

Architecture Patterns

• Sequential: Agents execute in fixed order (research → draft → review → publish)
• Hierarchical: Manager agent delegates to worker agents
• Graph-based: Agents connected in DAG or cyclic graphs for iterative refinement
• Swarm: Decentralized agents self-organize to solve problems
• Debate: Competing agents propose solutions, best wins
• Human-in-the-loop: Agents request human approval at checkpoints
• Shared memory: All agents read/write to common state
• Message passing: Agents communicate via structured messages

Code Example

# CrewAI: Role-based multi-agent system
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

# Define specialized agents
researcher = Agent(
    role="Research Analyst",
    goal="Gather comprehensive information on topics",
    backstory="Expert researcher with 10 years experience",
    llm=llm,
    tools=[search_tool, scrape_tool],
    verbose=True
)

writer = Agent(
    role="Content Writer",
    goal="Create engaging, well-structured articles",
    backstory="Professional writer specializing in technical content",
    llm=llm,
    verbose=True
)

editor = Agent(
    role="Editor",
    goal="Review and refine content for quality",
    backstory="Senior editor with keen eye for detail",
    llm=llm,
    verbose=True
)

# Define tasks
research_task = Task(
    description="Research the latest trends in {topic}",
    expected_output="Comprehensive research report with sources",
    agent=researcher
)

writing_task = Task(
    description="Write article based on research about {topic}",
    expected_output="1500-word article with introduction, body, conclusion",
    agent=writer,
    context=[research_task]  # Depends on research
)

editing_task = Task(
    description="Edit article for clarity, grammar, and flow",
    expected_output="Polished final article",
    agent=editor,
    context=[writing_task]
)

# Create crew with sequential process
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    verbose=True
)

# Execute
result = crew.kickoff(inputs={"topic": "Multi-Agent AI Systems"})
print(result)

# LangGraph: Graph-based agent workflow
from langgraph.graph import StateGraph, END
from typing import TypedDict, List

class AgentState(TypedDict):
    messages: List[str]
    research_done: bool
    draft_written: bool
    reviewed: bool

def research_agent(state: AgentState) -> AgentState:
    # Research the topic
    research = "Research findings: [data]"
    state["messages"].append(research)
    state["research_done"] = True
    return state

def writer_agent(state: AgentState) -> AgentState:
    # Write based on research
    draft = "Article draft: [content]"
    state["messages"].append(draft)
    state["draft_written"] = True
    return state

def reviewer_agent(state: AgentState) -> AgentState:
    # Review and potentially send back for revision
    review = "Needs revision" or "Approved"
    state["messages"].append(review)
    state["reviewed"] = (review == "Approved")
    return state

def should_continue(state: AgentState) -> str:
    if not state["reviewed"]:
        return "writer"  # Send back for revision
    return END

# Build graph
workflow = StateGraph(AgentState)
workflow.add_node("researcher", research_agent)
workflow.add_node("writer", writer_agent)
workflow.add_node("reviewer", reviewer_agent)

workflow.set_entry_point("researcher")
workflow.add_edge("researcher", "writer")
workflow.add_edge("writer", "reviewer")
workflow.add_conditional_edges("reviewer", should_continue)

app = workflow.compile()

# Execute with cycles for iterative improvement
initial_state = {"messages": [], "research_done": False, "draft_written": False, "reviewed": False}
final_state = app.invoke(initial_state)
print(final_state["messages"])

# AutoGen: Conversational agents
from autogen import AssistantAgent, UserProxyAgent

assistant = AssistantAgent(
    name="assistant",
    llm_config={"model": "gpt-4o", "api_key": "..."},
    system_message="You are a helpful AI assistant"
)

user_proxy = UserProxyAgent(
    name="user",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "coding"}
)

# Agents converse to solve problem
user_proxy.initiate_chat(
    assistant,
    message="Create a Python script to analyze CSV data"
)
# Assistant writes code, user_proxy executes it, they iterate until complete

Use Cases

• Software development: Multiple agents for design, coding, testing, deployment
• Research assistants: Research, synthesis, writing, citation management agents
• Customer support: Triage, technical, billing, escalation agents
• Business automation: Data extraction, analysis, reporting, decision agents
• Content creation: Research, writing, editing, SEO optimization agents
• Data analysis: Collection, cleaning, analysis, visualization agents
• Code review: Security, performance, style, testing validation agents
• Personal assistants: Email, scheduling, research, task management agents

Benefits vs Single Agents

Single agent limitations: Generic capabilities, limited context, sequential execution, no self-correction. Multi-agent advantages: Specialized expertise (research agent uses different prompts/tools than coding agent), parallel processing (3 agents working simultaneously = 3x faster), iterative refinement (reviewer sends work back for improvement), reduced errors (multiple validation layers), scalability (add agents without retraining). Benchmarks: Multi-agent systems achieve 20-40% higher success rates on complex tasks (software engineering, research) compared to single-agent approaches. Trade-off: Higher token costs (multiple LLM calls) and complexity.

Professional Integration Services by 21medien

21medien offers multi-agent system development including custom agent architecture design, CrewAI/LangGraph implementation, workflow optimization, and production deployment. Our team specializes in agent coordination patterns, tool integration, error handling, and human-in-the-loop workflows. We help organizations automate complex business processes through multi-agent orchestration. For detailed implementation guidance, see our blog post: Implementing Multi-Agent Systems (post #01). Contact us for custom multi-agent solutions.

Resources

CrewAI: https://github.com/joaomdmoura/crewAI | LangGraph: https://langchain-ai.github.io/langgraph/ | AutoGen: https://microsoft.github.io/autogen/ | Multi-agent blog post: /en/blog/implementing-multi-agent-systems