Multi-Agent Systems

Überblick

Multi-Agenten-Systeme zerlegen komplexe Aufgaben über spezialisierte Agenten: Ein Research-Agent sammelt Informationen, ein Coding-Agent schreibt Software, ein Reviewer-Agent validiert Qualität und ein Orchestrator koordiniert den Workflow. Vorteile: (1) Spezialisierung - jeder Agent meistert spezifische Fähigkeiten, (2) Parallele Ausführung - Agenten arbeiten simultan, (3) Fehlerkorrektur - Agenten überprüfen gegenseitig ihre Arbeit, (4) Skalierbarkeit - füge Agenten für neue Fähigkeiten hinzu. Frameworks wie CrewAI bieten rollenbasierte Agenten mit Tools und Memory. LangGraph ermöglicht graphbasierte Workflows mit Zyklen für iterative Verfeinerung. AutoGen unterstützt konversationelle Agenten mit Human-in-the-Loop. Anwendungen: Software Engineering (Devin, GPT Engineer), Forschungsassistenten, Kundensupport, Business-Process-Automatisierung.

Wichtige Frameworks (Oktober 2025)

• LangGraph: Graphbasierte Agenten-Workflows mit State-Management und Zyklen
• CrewAI: Rollenbasierte Agenten mit sequenzieller/hierarchischer Koordination
• Microsoft AutoGen: Konversationelle Agenten mit Human-in-the-Loop
• AutoGPT: Autonomer zielgesteuerter Agent mit Memory und Tools
• MetaGPT: Software-Engineering-Agenten simulieren Rollen (PM, Architekt, Engineer)
• OpenAI Assistants API: Multi-Agenten-Orchestrierung mit Function Calling
• LlamaIndex Workflows: Datenzentrierte Multi-Agenten-Pipelines
• Semantic Kernel: Microsofts Framework für Agenten-Orchestrierung

Architektur-Muster

• Sequenziell: Agenten führen in fester Reihenfolge aus (Research → Draft → Review → Publish)
• Hierarchisch: Manager-Agent delegiert an Worker-Agenten
• Graphbasiert: Agenten verbunden in DAG oder zyklischen Graphen für iterative Verfeinerung
• Swarm: Dezentralisierte Agenten organisieren sich selbst zur Problemlösung
• Debate: Konkurrierende Agenten schlagen Lösungen vor, beste gewinnt
• Human-in-the-Loop: Agenten fordern menschliche Genehmigung an Checkpoints
• Shared Memory: Alle Agenten lesen/schreiben in gemeinsamen State
• Message Passing: Agenten kommunizieren via strukturierte Nachrichten

Code-Beispiel

# 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

Anwendungsfälle

• Softwareentwicklung: Mehrere Agenten für Design, Coding, Testing, Deployment
• Forschungsassistenten: Research, Synthese, Writing, Zitations-Management-Agenten
• Kundensupport: Triage-, Technical-, Billing-, Escalation-Agenten
• Business-Automatisierung: Datenextraktion, Analyse, Reporting, Entscheidungs-Agenten
• Content-Erstellung: Research-, Writing-, Editing-, SEO-Optimierungs-Agenten
• Datenanalyse: Sammlung-, Cleaning-, Analyse-, Visualisierungs-Agenten
• Code-Review: Security-, Performance-, Style-, Testing-Validierungs-Agenten
• Persönliche Assistenten: Email-, Scheduling-, Research-, Task-Management-Agenten

Vorteile vs. Single-Agenten

Single-Agenten-Limitierungen: Generische Fähigkeiten, begrenzter Kontext, sequenzielle Ausführung, keine Selbstkorrektur. Multi-Agenten-Vorteile: Spezialisierte Expertise (Research-Agent nutzt andere Prompts/Tools als Coding-Agent), parallele Verarbeitung (3 Agenten arbeiten simultan = 3x schneller), iterative Verfeinerung (Reviewer sendet Arbeit zur Verbesserung zurück), reduzierte Fehler (mehrere Validierungs-Layer), Skalierbarkeit (füge Agenten ohne Retraining hinzu). Benchmarks: Multi-Agenten-Systeme erreichen 20-40% höhere Erfolgsraten bei komplexen Aufgaben (Software Engineering, Forschung) im Vergleich zu Single-Agenten-Ansätzen. Tradeoff: Höhere Token-Kosten (mehrere LLM-Aufrufe) und Komplexität.

Professionelle Integrationsdienste von 21medien

21medien bietet Multi-Agenten-System-Entwicklung an, einschließlich benutzerdefiniertem Agenten-Architektur-Design, CrewAI/LangGraph-Implementierung, Workflow-Optimierung und Produktionsbereitstellung. Unser Team ist spezialisiert auf Agenten-Koordinationsmuster, Tool-Integration, Fehlerbehandlung und Human-in-the-Loop-Workflows. Wir helfen Organisationen, komplexe Geschäftsprozesse durch Multi-Agenten-Orchestrierung zu automatisieren. Für detaillierte Implementierungsanleitungen siehe unseren Blogpost: Implementing Multi-Agent Systems (Post #01). Kontaktieren Sie uns für maßgeschneiderte Multi-Agenten-Lösungen.

Ressourcen

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