1~
2AI-Agenten haben sich von Forschungsdemos zu Produktionssystemen entwickelt. Uber 60% der Enterprise-AI-Anwendungen werden voraussichtlich bis 2026 agentische Komponenten enthalten. Aber Agenten von Grund auf zu bauen  -  Tool-Schleifen, State, Speicher, Fehlerbehandlung und Multi-Agenten-Koordination zu verwalten  -  ist komplex. Genau hier kommen Frameworks ins Spiel.
3~
4Vier Frameworks dominieren 2026: **LangGraph**, **CrewAI**, **OpenAI Agents SDK** und **Claude Agent SDK**. Jedes verfolgt einen grundlegend anderen Ansatz fur dasselbe Problem: LLMs die Fahigkeit zu geben, zu denken, zu planen, Tools zu nutzen und zusammenzuarbeiten.
5~
6## Auf einen Blick
7~
8| Aspekt | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Von** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Architektur** | Graph-basiert | Rollenbasiert | Handoff-basiert | Autonome Schleife |
12| **Philosophie** | Maximale Kontrolle | Teamzusammenarbeit | Minimale Abstraktion | Gib dem Agenten einen Computer |
13| **Sprachen** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Modellunterstutzung** | Alle (OpenAI, Claude, lokal) | Alle | Alle (trotz des Namens) | Nur Claude |
15| **GitHub Stars** | ~29k | ~40k | ~21k | ~6k |
16| **Am besten fur** | Komplexe zustandsbehaftete Workflows | Multi-Agenten-Spezialisierung | Routing und Triage | Coding und dateiintensive Aufgaben |
17~
18## LangGraph: Der Graph-Baumeister
19~
20LangGraph modelliert Agenten-Workflows als **gerichtete zyklische Graphen**. Sie definieren Knoten (Funktionen, die Arbeit verrichten) und Kanten (Ubergange zwischen ihnen, optional bedingt). State fliesst durch den Graphen und wird uber Checkpointing persistiert.
21~
22Dies ist das expliziteste und kontrollierteste Framework  -  Sie verdrahten jeden Schritt selbst.
23~
24```mermaid
25graph LR
26    Start --> Router[Router Node]
27    Router -->|needs research| Research[Research Node]
28    Router -->|needs code| Code[Code Node]
29    Research --> Synthesize[Synthesize Node]
30    Code --> Synthesize
31    Synthesize --> End
32```
33~
34### Kernkonzepte
35~
36- **StateGraph**: die Graph-Definition mit typisiertem State
37- **Nodes**: Python-Funktionen, die State transformieren
38- **Edges**: Verbindungen zwischen Knoten, konnen bedingt sein
39- **Checkpointing**: integrierte Persistenz fur langlebige Workflows
40~
41### Codebeispiel
42~
43```python
44from langgraph.graph import StateGraph, MessagesState, START, END
45from langchain_openai import ChatOpenAI
46~
47llm = ChatOpenAI(model="gpt-4o")
48~
49def call_agent(state: MessagesState):
50    response = llm.invoke(state["messages"])
51    return {"messages": [response]}
52~
53def should_continue(state: MessagesState):
54    last = state["messages"][-1]
55    if last.tool_calls:
56        return "tools"
57    return END
58~
59def call_tools(state: MessagesState):
60    # Execute tool calls and return results
61    results = []
62    for tool_call in state["messages"][-1].tool_calls:
63        result = execute_tool(tool_call)
64        results.append(result)
65    return {"messages": results}
66~
67graph = StateGraph(MessagesState)
68graph.add_node("agent", call_agent)
69graph.add_node("tools", call_tools)
70graph.add_edge(START, "agent")
71graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
72graph.add_edge("tools", "agent")
73~
74app = graph.compile()
75result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
76```
77~
78### Starken
79~
80- Feingranulare Kontrolle uber jeden Schritt und Ubergang
81- Integriertes Checkpointing und Human-in-the-Loop
82- Volle TypeScript-Paritat
83- Funktioniert mit jedem LLM-Anbieter
84- Am besten fur komplexe Workflows mit bedingter Verzweigung und Schleifen
85~
86### Schwachen
87~
88- Steile Lernkurve  -  Sie mussen Graphentheorie-Konzepte verstehen
89- Umstandlich fur einfache Anwendungsfalle  -  ein einfacher Agent erfordert mehr Boilerplate als andere Frameworks
90- Das Debuggen von Graph-Ablaufen kann ohne LangSmith herausfordernd sein
91~
92### Preise
93~
94Open-Source (MIT). LangSmith (verwaltete Observability-Plattform) hat kostenpflichtige Stufen fur Produktionsmonitoring.
95~
96## CrewAI: Der Team-Zusammensteller
97~
98CrewAI nutzt eine menschliche Metapher: Sie stellen eine **Crew** spezialisierter Agenten zusammen, jeder mit einer **Rolle**, einem **Ziel** und einer **Hintergrundgeschichte**. Agenten arbeiten an **Aufgaben** mit **Tools** zusammen, koordiniert durch einen **Prozess** (sequentiell, hierarchisch oder konsensbasiert).
99~
100Stellen Sie es sich vor wie das Einstellen eines Teams, in dem jedes Mitglied eine bestimmte Berufsbezeichnung und Spezialisierung hat.
101~
102```mermaid
103graph TD
104    Crew[Crew Manager] --> R[Researcher\nRole: Find data\nTools: WebSearch]
105    Crew --> W[Writer\nRole: Write content\nTools: FileWrite]
106    Crew --> E[Editor\nRole: Review quality\nTools: FileRead]
107    R --> Task1[Research Task]
108    W --> Task2[Writing Task]
109    E --> Task3[Review Task]
110    Task1 --> Task2 --> Task3
111```
112~
113### Kernkonzepte
114~
115- **Agent**: eine Persona mit Rolle, Ziel, Hintergrundgeschichte und Tools
116- **Task**: ein Auftrag mit Beschreibung, erwartetem Output und zugewiesenem Agent
117- **Crew**: eine Gruppe von Agenten, die zusammenarbeiten
118- **Process**: Ausfuhrungsstrategie (sequentiell, hierarchisch, konsensbasiert)
119- **Flow**: ereignisgesteuerte Orchestrierungsschicht fur die Verbindung mehrerer Crews
120~
121### Codebeispiel
122~
123```python
124from crewai import Agent, Task, Crew, Process
125~
126researcher = Agent(
127    role="Senior Research Analyst",
128    goal="Find comprehensive data about the given topic",
129    backstory="You have 10 years of experience in technology research. "
130              "You are thorough and always verify facts from multiple sources.",
131    tools=[web_search_tool],
132    verbose=True,
133)
134~
135writer = Agent(
136    role="Technical Writer",
137    goal="Create clear, engaging technical content",
138    backstory="You write for a developer audience. "
139              "Your articles are practical and include code examples.",
140    tools=[file_tool],
141    verbose=True,
142)
143~
144research_task = Task(
145    description="Research the latest developments in WebAssembly in 2026. "
146                "Focus on WASI, Component Model, and production use cases.",
147    expected_output="A structured research document with key findings and sources.",
148    agent=researcher,
149)
150~
151writing_task = Task(
152    description="Write a blog post based on the research. "
153                "Include code examples and Mermaid diagrams.",
154    expected_output="A complete blog post in Markdown format.",
155    agent=writer,
156    context=[research_task],  # Writer receives researcher's output
157)
158~
159crew = Crew(
160    agents=[researcher, writer],
161    tasks=[research_task, writing_task],
162    process=Process.sequential,
163    verbose=True,
164)
165~
166result = crew.kickoff()
167print(result.raw)
168```
169~
170### Starken
171~
172- Intuitive rollenbasierte Abstraktion  -  leicht nachvollziehbar
173- Uber 100 integrierte Tool-Integrationen
174- Geteilter Speicher uber Agenten hinweg (Kurzzeit, Langzeit, Entity)
175- Grosste Community (~40k GitHub Stars)
176- Hierarchischer Prozess mit einem "Manager"-Agenten, der delegiert und validiert
177~
178### Schwachen
179~
180- Weniger feingranulare Kontrolle als LangGraph  -  Sie definieren Rollen, nicht exakte Ausfuhrungspfade
181- Hierarchischer Prozess kann unvorhersehbar sein, wenn Agenten sich uneinig sind
182- Das Debuggen von Multi-Agenten-Konversationen ist schwieriger als bei Einzelagenten-Ablaufen
183~
184### Preise
185~
186Open-Source-Kern (kostenlos). CrewAI Platform: 99$/Monat (Teams) bis 120.000$/Jahr (Enterprise). Preise basieren auf aktiven Crews und monatlichen Ausfuhrungen.
187~
188## OpenAI Agents SDK: Der Router
189~
190Das OpenAI Agents SDK (geistiger Nachfolger von Swarm) konzentriert sich auf **Handoffs**  -  Agenten, die Konversationen an andere spezialisierte Agenten ubergeben. Es ist das minimalste Framework: Agenten, Tools, Handoffs und Guardrails. Das ist alles.
191~
192```mermaid
193graph LR
194    User --> Triage[Triage Agent]
195    Triage -->|billing question| Billing[Billing Agent]
196    Triage -->|refund request| Refund[Refund Agent]
197    Triage -->|technical issue| Support[Support Agent]
198    Billing --> Response[Response]
199    Refund --> Response
200    Support --> Response
201```
202~
203### Kernkonzepte
204~
205- **Agent**: Modell + Anweisungen + Tools + Handoffs
206- **Handoff**: eine Ubergabe an einen anderen Agenten (als Tool modelliert, das das LLM aufrufen kann)
207- **Guardrail**: Eingabe-/Ausgabevalidierung, die parallel zum Agenten lauft
208- **Runner**: fuhrt die Agenten-Schleife aus
209- **Tracing**: integrierte Observability fur alle LLM-Aufrufe, Tool-Ausfuhrungen und Handoffs
210~
211### Codebeispiel
212~
213```python
214from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
215from pydantic import BaseModel
216~
217class SafetyCheck(BaseModel):
218    is_safe: bool
219    reason: str
220~
221async def content_safety(ctx, agent, input_text):
222    result = await Runner.run(
223        Agent(name="Safety", instructions="Check if input is safe. No PII."),
224        input_text,
225        context=ctx,
226    )
227    output = SafetyCheck.model_validate_json(result.final_output)
228    return GuardrailFunctionOutput(
229        output_info=output, tripwire_triggered=not output.is_safe
230    )
231~
232billing_agent = Agent(
233    name="Billing Agent",
234    instructions="You handle billing inquiries. Be precise with numbers.",
235    tools=[lookup_invoice, process_payment],
236)
237~
238refund_agent = Agent(
239    name="Refund Agent",
240    instructions="You process refund requests. Always verify the order first.",
241    tools=[lookup_order, issue_refund],
242)
243~
244triage_agent = Agent(
245    name="Triage Agent",
246    instructions="Route the customer to the right specialist. "
247                 "Ask clarifying questions if needed.",
248    handoffs=[billing_agent, refund_agent],
249    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
250)
251~
252result = await Runner.run(triage_agent, "I need a refund for order #4521")
253print(result.final_output)
254# The triage agent routes to refund_agent, which processes the refund
255```
256~
257### Starken
258~
259- Sauberes Handoff-Muster  -  naturlich fur Routing-/Triage-Workflows
260- Guardrails laufen parallel zur Ausfuhrung (Fail-Fast, nicht blockierend)
261- Integriertes Tracing-Dashboard zum Debuggen
262- Unterstutzt trotz des Namens auch Nicht-OpenAI-Modelle
263- Minimale Abstraktion  -  leicht verstandlich und erweiterbar
264~
265### Schwachen
266~
267- Weniger ausgereiftes State-Management als LangGraph
268- Keine integrierte Persistenz oder Checkpointing
269- Okosystem an Drittanbieter-Tools ist kleiner
270- Handoff-zentriertes Design passt moglicherweise nicht zu jeder Architektur
271~
272### Preise
273~
274Open-Source (MIT). Sie zahlen pro Token fur das jeweilige Modell.
275~
276## Claude Agent SDK: Der Entwickler
277~
278Das Claude Agent SDK verfolgt einen anderen Ansatz: Anstatt Workflows oder Rollen zu definieren, geben Sie dem Agenten eine **Sammlung von Tools und lassen ihn herausfinden, wie er die Aufgabe erledigt**. Es nutzt dieselbe autonome Schleife, die Claude Code antreibt  -  lesen, handeln, verifizieren, iterieren.
279~
280```mermaid
281graph TD
282    Prompt[User Prompt] --> Loop[Autonomous Agent Loop]
283    Loop --> Reason[Reason about next step]
284    Reason --> Act[Execute tool]
285    Act --> Verify[Check result]
286    Verify -->|not done| Loop
287    Verify -->|done| Output[Final output]
288```
289~
290### Kernkonzepte
291~
292- **query()**: der Haupteinstiegspunkt, der die Agenten-Schleife startet
293- **Integrierte Tools**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Benutzerdefinierte Tools via MCP**: Tools als In-Process-MCP-Server definieren
295- **Sub-Agenten**: spezialisierte Agenten, an die der ubergeordnete Agent delegieren kann
296- **Sessions**: Kontext uber mehrere Interaktionen hinweg beibehalten
297~
298### Codebeispiel
299~
300```typescript
301import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
302import { z } from "zod";
303~
304const searchDocs = tool(
305  "search_docs",
306  "Search the internal documentation for relevant information",
307  { query: z.string().describe("Search query") },
308  async ({ query }) => {
309    const results = await vectorStore.similaritySearch(query, 5);
310    return {
311      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
312    };
313  }
314);
315~
316const docsServer = createSdkMcpServer({
317  name: "docs",
318  version: "1.0.0",
319  tools: [searchDocs],
320});
321~
322for await (const message of query({
323  prompt: "Find how authentication works in our system and write a summary",
324  options: {
325    mcpServers: { docs: docsServer },
326    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
327  },
328})) {
329  if (message.type === "result" && message.subtype === "success") {
330    console.log(message.result);
331  }
332}
333```
334~
335### Starken
336~
337- Erstklassige MCP-Integration  -  Verbindung zu jedem MCP-Server-Okosystem
338- Integrierte Tools fur Dateioperationen, Terminal und Webzugriff
339- Automatische Kontextkomprimierung fur grosse Codebasen
340- Sub-Agenten-Parallelismus fur komplexe Aufgaben
341- Derselbe Motor wie Claude Code  -  kampferprobt in echten Entwicklungsworkflows
342~
343### Schwachen
344~
345- Nur Claude-Modelle  -  keine Multi-Provider-Unterstutzung
346- Neueres Framework mit kleinerer Community
347- Erfordert Node.js-Runtime auch fur das Python SDK
348- Weniger explizite Workflow-Kontrolle im Vergleich zu LangGraph
349~
350### Preise
351~
352Open-Source. Standard-Claude-API-Tokenpreise. Managed Agents (gehostete Version): 0,08$ pro Sitzungsstunde zusatzlich zu den Tokenkosten.
353~
354## Wann welches wahlen
355~
356```mermaid
357graph TD
358    Start{What's your priority?}
359    Start -->|Full control over workflow| LG[LangGraph]
360    Start -->|Multi-agent collaboration| CA[CrewAI]
361    Start -->|Routing and triage| OA[OpenAI Agents SDK]
362    Start -->|Coding and file automation| CS[Claude Agent SDK]
363~
364    LG --> LGU[Complex stateful workflows\nConditional branching\nHuman-in-the-loop]
365    CA --> CAU[Team of specialized agents\nResearch + writing pipelines\nContent generation]
366    OA --> OAU[Customer service routing\nMulti-step handoffs\nInput validation]
367    CS --> CSU[Code generation and review\nFile-heavy automation\nMCP tool ecosystem]
368```
369~
370### Wahlen Sie LangGraph, wenn:
371- Sie prazise Kontrolle uber jeden Schritt des Workflows benotigen
372- Ihr Anwendungsfall komplexe bedingte Logik und Schleifen umfasst
373- Sie integrierte Persistenz und Human-in-the-Loop-Checkpoints wollen
374- Sie mehrere LLM-Anbieter im selben Workflow nutzen mussen
375~
376### Wahlen Sie CrewAI, wenn:
377- Sie eine intuitive, rollenbasierte Abstraktion wollen
378- Ihre Aufgabe mehrere Agenten mit unterschiedlichen Spezialisierungen umfasst
379- Sie Agenten brauchen, die zusammenarbeiten und Kontext untereinander weitergeben
380- Ihnen die grosste Community und die meisten integrierten Integrationen wichtig sind
381~
382### Wahlen Sie OpenAI Agents SDK, wenn:
383- Ihr Hauptmuster das Routing von Konversationen an Spezialisten ist
384- Sie Guardrails benotigen, die Eingabe/Ausgabe parallel validieren
385- Sie die einfachstmogliche Abstraktion mit minimalem Boilerplate wollen
386- Integriertes Tracing und Observability wichtig sind
387~
388### Wahlen Sie Claude Agent SDK, wenn:
389- Ihre Agenten Code lesen, schreiben und ausfuhren mussen
390- Sie erstklassige MCP-Server-Integration wollen
391- Sie autonome Agenten brauchen, die iterieren und sich selbst korrigieren
392- Sie bereits Claude nutzen und die tiefste Integration wollen
393~
394## Kann man Frameworks kombinieren?
395~
396Ja. Ein gangiges Muster ist, ein Framework fur die Orchestrierung und ein anderes fur einzelne Agenten zu verwenden:
397~
398- **LangGraph** fur den gesamten Workflow-Graphen
399- **CrewAI** fur einen bestimmten Knoten, der Multi-Agenten-Zusammenarbeit erfordert
400- **Claude Agent SDK** fur codierungsbezogene Teilaufgaben via MCP
401- **OpenAI Agents SDK** fur kundenorientiertes Triage und Routing
402~
403Die Frameworks schliessen sich nicht gegenseitig aus. Nutzen Sie das, was zu jedem Teil Ihres Systems passt.
404~
405## Fazit
406~
407Jedes Framework setzt auf einen klaren Schwerpunkt:
408~
409- **LangGraph** optimiert fur Kontrolle  -  Sie bestimmen jeden Ubergang
410- **CrewAI** optimiert fur Zusammenarbeit  -  Agenten arbeiten als Team
411- **OpenAI Agents SDK** optimiert fur Einfachheit  -  minimale Abstraktion, saubere Handoffs
412- **Claude Agent SDK** optimiert fur Autonomie  -  geben Sie ihm Tools und lassen Sie es arbeiten
413~
414Die richtige Wahl hangt von Ihrem Workflow, Ihrem Team und Ihrem bestehenden Stack ab. Wahlen Sie das, das zu Ihrem Hauptanwendungsfall passt, lernen Sie es gut kennen und ziehen Sie andere hinzu, wenn Sie deren Starken benotigen.
415~