Multi-Agent Frameworks

Wissen

Bevor wir über Frameworks reden, die wichtigste Frage zuerst:

Wann lohnt sich ein Framework?

• Ab 4+ Agents mit komplexer Kommunikation
• Wenn du dynamische Workflows brauchst (Agents werden zur Laufzeit erstellt/entfernt)
• Wenn du State Management über mehrere Agent-Schritte brauchst
• Wenn du Parallelisierung und Fehlerbehandlung nicht selbst implementieren willst

LangGraph (Python/TypeScript, Graph-basiert)

LangGraph modelliert Multi-Agent Workflows als gerichtete Graphen. Jeder Knoten ist ein Agent oder eine Funktion, jede Kante definiert den Datenfluss. Das gibt dir maximale Kontrolle über den Workflow -- auf Kosten von mehr Boilerplate.

from langgraph.graph import StateGraph, END

# State definiert, was zwischen Agents geteilt wird
class AgentState(TypedDict):
    messages: list[str]
    current_task: str
    results: dict

# Graph aufbauen
workflow = StateGraph(AgentState)

# Agents als Knoten hinzufügen
workflow.add_node("researcher", research_agent)
workflow.add_node("analyzer", analysis_agent)
workflow.add_node("writer", writer_agent)

# Kanten definieren den Workflow
workflow.add_edge("researcher", "analyzer")
workflow.add_conditional_edges(
    "analyzer",
    should_continue,  # Funktion entscheidet den nächsten Schritt
    {"write": "writer", "research_more": "researcher"}
)
workflow.add_edge("writer", END)

Stärken: Volle Kontrolle, State Management, Checkpointing, Debugging (Graph-Viz), breites Ökosystem. Schwächen: Verbose, steile Lernkurve.

Mastra (TypeScript, Deklarativ / Graph-basiert)

Mastra setzt auf ein deklaratives, graph-basiertes Modell und ist für TypeScript/Node.js-Teams gebaut. Workflows werden als Schritte mit Bedingungen definiert, und der Graph ergibt sich aus der deklarierten Schritt-Abfolge.

import { Agent, Workflow } from '@mastra/core';

const researchAgent = new Agent({
  name: 'researcher',
  model: 'claude-sonnet-5',
  instructions: 'Du recherchierst Informationen zu einem Thema.',
  tools: [webSearch, documentReader],
});

const analysisWorkflow = new Workflow({
  name: 'analysis-pipeline',
  steps: [
    { agent: researchAgent, input: (ctx) => ctx.query },
    { agent: analyzerAgent, input: (prev) => prev.result },
    {
      condition: (prev) => prev.confidence < 0.8,
      then: { agent: researchAgent, input: (prev) => prev.gaps },
      else: { agent: writerAgent, input: (prev) => prev.analysis },
    },
  ],
});

Stärken: TypeScript-nativ, deklarativ, wenig Boilerplate, Web-Integration. Schwächen: Jüngeres Ökosystem, weniger Kontrolle, Checkpoint-Support noch nicht ausgereift.

CrewAI (Python, Role-based)

CrewAI denkt in Rollen und Teams, nicht in Graphen oder Events. Du definierst Agents mit Rollen ("Senior Developer", "QA Engineer"), gibst ihnen Aufgaben und lässt sie als Team zusammenarbeiten.

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Senior Research Analyst",
    goal="Finde die relevantesten Informationen zum Thema",
    backstory="Du hast 15 Jahre Erfahrung in der Marktforschung.",
    tools=[web_search, document_reader],
    llm="claude-sonnet-5"
)

writer = Agent(
    role="Technical Writer",
    goal="Erstelle einen klaren, strukturierten Bericht",
    backstory="Du schreibst seit Jahren technische Dokumentation.",
    llm="claude-haiku-4-5"
)

research_task = Task(
    description="Analysiere den aktuellen Stand von {topic}",
    agent=researcher,
    expected_output="Strukturierte Zusammenfassung mit Quellen"
)

write_task = Task(
    description="Schreibe einen Bericht basierend auf der Recherche",
    agent=writer,
    expected_output="Fertiger Bericht im Markdown-Format",
    context=[research_task]  # Abhängigkeit
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    verbose=True
)

Stärken: Intuitiv, wenig Code, Delegation, schneller Start. Schwächen: Weniger Kontrolle, Debugging schwieriger, Skalierung begrenzt.

Verstehen

Framework-Vergleich: Wann welches?

Anwenden

Reflektieren

Frameworks sind Werkzeuge, keine Lösung. Die wichtigste Entscheidung ist nicht welches Framework, sondern ob du überhaupt eines brauchst. Mit der Faustregel "unter 4 Agents kein Framework" und dem Verständnis der Stärken jedes Frameworks triffst du fundierte Architekturentscheidungen.