LangGraph, OpenAI Agents SDK oder Claude Agent SDK: Passen Sie das Primitive zum Aufgabentyp an.
Vier Beispielaufgaben – Sprache, langlebige Rückerstattungen, Code-Migration und MCP-Operationen – zeigen an, welches Agent-Framework zu welchem Zeitpunkt geeignet ist, mit Hinweisen zu Bindungseffekten, Langlebigkeit und Echtzeitfunktionen.
Quellen: The Best Agent Framework in 2026: LangGraph vs OpenAI Agents SDK vs Claude Agent SDK
Die Vergleiche im Jahr 2026 kehren immer wieder zu drei Agentenframeworks zurück, wobei jedes auf einer anderen Grundidee beruht. LangGraph ist ein Graphen-Runtime, bei dem Knoten einfache Funktionen sind und Kanten die Übergänge bestimmen. Das OpenAI Agents SDK konzentriert sich auf die Übertragung von Aufgaben, wobei ein Agent Arbeit durch typisierte Sitzungen an einen anderen weitergibt, wobei MCP nativ unterstützt wird. Das Claude Agent SDK ist das Unerwartete: Es stellt dem Agenten einen Computer zur Verfügung, da Anthropic es auf Bash-Ausführungen, Dateienschreibvorgängen und Hooks aufgebaut hat, in der Überzeugung, dass ein leistungsstarker Agent eine echte Shell benötigt.
Die richtige Wahl hängt von etwas ab, was Architekturvergleiche selten berücksichtigen: Welche Art von Arbeit erledigt der Agent?
Die drei Primitiven
LangGraph richtet sich an statebasierte Workflows. Es wird ein Zustandsschema deklariert, und ein typisierter Objekt bewegt sich durch das Graphen vom ersten zum letzten Knoten. Da die Checkpoint-Funktionen diesen Zustand an jedem Knoten speichern, kann eine Ausführung nach einem Absturz oder nach Wartezeit auf eine menschliche Freigabe mit ihrem Kontext unverändert fortgesetzt werden. Der create_agent-Aufruf, der mit LangChain 1.0 verfügbar wurde – allgemein verfügbar ab dem 22. Oktober 2025 – ist lediglich eine Fassade für diesen Laufzeitmechanismus, wodurch die alte Debatte zwischen LangChain und LangGraph beendet wird.
Das OpenAI Agents SDK verfügt über neun Kernbausteine, darunter Agents, Handoffs, Tools, Guardrails, Sessions und Realtime. Seine atomare Einheit ist ein Agent, der eine Aufgabe an einen anderen weitergibt. Die Unabhängigkeit von Anbietern kam 2025 mit der Unterstützung für mehr als 100 Modelle über LiteLLM. MCP ist ein erstklassiger Tool-Typ, und Sprachfunktionen sind bei der gpt-realtime-2-Modellfamilie standardmäßig enthalten.
Das Claude Agent SDK basiert auf einer Shell-Umgebung. Sein Werkzeugkasten enthält Bash, Read, Write, Edit, Glob und Grep sowie Lebenszyklus-Hooks mit den Namen PreToolUse, PostToolUse und Stop, und Subagenten, die in separaten, isolierten Kontextfenstern laufen. Anthropic änderte Ende 2025 den Namen von Claude Code SDK, da das Framework nicht nur zum Programmieren, sondern auch für tiefgehende Forschung, Videoerstellung und Notizenführung genutzt werden kann. Nur Claude-Modelle sind zulässig, obwohl Bedrock, Vertex und Azure Foundry es hosten können.
Eine Annahme aus 2025, die überholt ist
Eine gängige Annahme aus dem letzten Jahr besagt, dass das OpenAI Agents SDK ausschließlich OpenAI-Modelle erzwingt. Das ist bereits etwa fünfzehn Monate veraltet. Das offizielle Repository unterstützt die OpenAI Responses API sowie rund 100 weitere Modelle durch Integrationen mit LiteLLM und Any-LLM.
# Install: pip install "openai-agents[litellm]"
# Env: export GEMINI_API_KEY=...
import os
from agents import Agent, Runner, function_tool
from agents.extensions.models.litellm_model import LitellmModel
@function_tool
def current_time_utc() -> str:
"""Return the current UTC time as an ISO-8601 string."""
from datetime import datetime, timezone
return datetime.now(timezone.utc).isoformat(timespec="seconds")
# OpenAI Agents SDK using Gemini via LiteLLM. No OpenAI key required.
gemini_model = LitellmModel(
model="gemini/gemini-2.5-pro",
api_key=os.environ["GEMINI_API_KEY"],
)
agent = Agent(
name="time-agent",
instructions="Answer time questions using the current_time_utc tool.",
model=gemini_model,
tools=[current_time_utc],
)
result = Runner.run_sync(agent, "What is the current UTC time?")
print(result.final_output)
# -> "The current UTC time is 2026-07-06T14:32:11+00:00."
Die Erstellung eines LitellmModel unter Verwendung eines Gemini-Modellnamens zeigt, dass das Framework außerhalb des OpenAI-Ökosystems arbeitet, und der @function_tool-Decorator verhält sich unabhängig vom zugrunde liegenden Modell genauso. Nicht-OpenAI-Pfade werden als „Best Effort“ dokumentiert, wobei die Funktionalität je nach Anbieter variiert. Da strenge Modellbeschränkungen nicht in Frage kommen, konkurrieren die Frameworks mit ihren architektonischen Grundelementen.
Ein Testunternehmen mit vier Agenten
Nehmen wir ein mittelgroßes Fintech-Unternehmen namens Meridian, bei dem vier Agenten in verschiedenen Teams entwickelt werden.
- Ein Sprachsupport-Agent, der telefonisch Fragen zur Abrechnung beantwortet.
- Ein mehragentiger Rückerstattungsworkflow, der vor der Weiterleitung des Tickets an die Finanzabteilung Betrugsregeln überprüft.
- Ein interner Code-Migration-Agent, der durch ein großes Java-Repository geht, Syntaxumwandlungen anwendet und Pull-Requests erstellt.
Die folgenden vier Konfigurationen zeigen an, welches Framework zu welchem Szenario passt.
Arbeitslast eins: Sprache und Echtzeit-Streaming
Das Team für Sprachfunktionen arbeitet innerhalb eines strengen Latenzlimits von unter 500 ms für das Streaming und muss zudem Umgang mit Störungen durch Nutzer ermöglichen. Der Prozess von Sprache zu Text, gefolgt von einem Textmodell, das wiederum Text in Sprache umwandelt, ist zu langsam, da jeder Netzwerkwechsel Verzögerungen verursacht.
Das OpenAI Agents SDK eignet sich hierfür. Das gpt-realtime-2-Modell streamt Audio-Token nativ, und RealtimeAgent nutzt diese Funktion. Weder LangGraph noch das Claude Agent SDK boten Mitte 2026 eine native Echtzeitfunktion auf diesem Niveau an.
# Install: pip install openai-agents
# Env: export OPENAI_API_KEY=...
import asyncio
from agents import function_tool
from agents.realtime import RealtimeAgent, RealtimeRunner
@function_tool
def lookup_billing_balance(account_id: str) -> str:
"""Return the current outstanding balance for an account."""
# In production, this hits the billing service. Here it is a stub.
return "42.17 USD outstanding as of 2026-07-06."
voice_agent = RealtimeAgent(
name="meridian-billing-voice",
instructions=(
"You are Meridian's billing voice assistant. Answer politely, briefly. "
"Confirm the account_id before disclosing any balance."
),
tools=[lookup_billing_balance],
)
async def main():
runner = RealtimeRunner(
starting_agent=voice_agent,
config={"model_settings": {"model_name": "gpt-realtime-2.1"}},
)
# session handles the audio stream and tool calls
session = await runner.run()
async with session:
# Wire the audio input source here via sounddevice or pyaudio
async for event in session:
if event.type == "history_updated":
# The item contains the finalized transcript once the turn ends
print(f"History updated with item: {event.item}")
elif event.type == "error":
print(f"Error: {event.error}")
break
asyncio.run(main())
RealtimeAgent und RealtimeSession kümmern sich um die einlaufenden und ausgehenden Audioströme sowie den Tool-Aufruf-Zyklus. Tools, die mit @function_tool deklariert sind, laufen in einer Echtzeit-Sitzung genauso wie in einem Text-Agenten. Das Framework macht den Event-Zyklus sichtbar, während der WebSocket-Zustand verborgen bleibt.
Die Umsetzung dieser Funktionalität in LangGraph oder dem Claude Agent SDK würde einen eigenen WebSocket-Code, eine Stimmenaktivitätserkennung sowie komplexe Unterbrechungsschemata erfordern, wodurch ein Agentenprojekt zu einem Mediapipeline-Projekt wird. Wenn die Unternehmensrichtlinien die Verwendung von Claude oder Gemini für das Sprachmodell vorschreiben, ändert sich die Situation. Anthropic fügte später Echtzeitfunktionen hinzu, daher sollten alle, die nach Mitte 2026 lesen, auf die Funktionsgleichheit achten.
Arbeitslast zwei: dauerhafte Orchestrierung mit menschlicher Freigabe
Der Rückzahlungsablauf erfordert eine Betrugsprüfung, anschließend die Übermittlung an die Finanzabteilung zur Freigabe, einen Wartezeitraum für die menschliche Prüfung bei Rückzahlungen über 500 Dollar sowie eine endgültige Entscheidung, die wieder in Postgres geschrieben wird. Er muss Serverausfälle überstehen und asynchrone Pausen durch Menschen ohne Verlust des Kontexts bewältigen.
LangGraph eignet sich dafür. Checkpointer in Kombination mit der Unterbrechungsfunktion bieten genau den Kontrollfluss, den langlaufende Geschäftsprozesse benötigen. Produktionsteams unterstützen diese Architektur: Uber gibt an, mit LangGraph für seine AutoCover- und Validator-Systeme etwa 21.000 Entwicklerstunden einsparen zu können, und LinkedIn veröffentlichte eine Studie über einen hierarchischen semantischen Speichertree für sein Hiring Assistant-System, wobei das Design der Überwacher und Unteragenten in separaten LangChain-Technologievorträgen behandelt wird.
from typing import TypedDict, Literal
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import MemorySaver
from langgraph.types import interrupt, Command
from langchain_google_genai import ChatGoogleGenerativeAI
# LangGraph is provider-agnostic. Here it uses Gemini.
llm = ChatGoogleGenerativeAI(model="gemini-2.5-pro", temperature=0)
class RefundState(TypedDict):
order_id: str
amount_usd: float
customer_reason: str
fraud_risk: Literal["low", "medium", "high"] | None
finance_decision: Literal["approved", "denied"] | None
human_review_needed: bool
def fraud_check(state: RefundState) -> RefundState:
"""Run the LLM-backed fraud check against the customer's stated reason."""
prompt = (
f"Assess fraud risk for refund of ${state['amount_usd']:.2f}. "
f"Customer reason: {state['customer_reason']!r}. "
"Respond with one word: low, medium, or high."
)
verdict = llm.invoke(prompt).content.strip().lower()
if verdict not in {"low", "medium", "high"}:
verdict = "high" # fail-closed on ambiguous LLM output
return {**state, "fraud_risk": verdict}
def finance_approval(state: RefundState) -> RefundState:
"""Above $500 or medium risk, pause for a human. Otherwise auto-approve."""
needs_human = state["amount_usd"] > 500 or state["fraud_risk"] in {"medium", "high"}
if needs_human:
# Pause the graph. On resume, interrupt returns the human's decision.
human_decision = interrupt({
"order_id": state["order_id"],
"amount_usd": state["amount_usd"],
"fraud_risk": state["fraud_risk"],
"prompt": "Approve (yes/no)?",
})
return {**state, "human_review_needed": True, "finance_decision": human_decision}
return {**state, "human_review_needed": False, "finance_decision": "approved"}
# Build the graph
graph = StateGraph(RefundState)
graph.add_node("fraud_check", fraud_check)
graph.add_node("finance_approval", finance_approval)
graph.add_edge(START, "fraud_check")
graph.add_conditional_edges(
"fraud_check",
lambda s: "finance_approval" if s["fraud_risk"] != "high" else END,
)
graph.add_edge("finance_approval", END)
# Checkpointer. For production, swap MemorySaver for PostgresSaver.
compiled = graph.compile(checkpointer=MemorySaver())
# Run it. Interrupt fires on the $850 refund and the graph pauses.
config = {"configurable": {"thread_id": "order-4291"}}
result = compiled.invoke(
{
"order_id": "4291",
"amount_usd": 850.00,
"customer_reason": "arrived damaged, no photo",
"fraud_risk": None,
"finance_decision": None,
"human_review_needed": False,
},
config=config,
)
# Later, a human reviewer says yes. Resume with Command.
final = compiled.invoke(Command(resume="approved"), config=config)
Muster der Pause und Wiederaufnahme zeigen eine zuverlässige Ausführung im Code. Das Aufrufen von interrupt() innerhalb des Finanzfreigaben-Nodes schreibt den aktuellen Zustand in den Checkpointer, wodurch das System an diesem Punkt abgeschaltet werden kann. Stunden später setzt ein Befehl mit dem Wert „approved“ die Ausführung an der gepausierten Stelle unter derselben Thread-ID fort, ohne die Betrugsprüfung erneut durchzuführen.
Es gibt jedoch eine Einschränkung hinsichtlich der Zuverlässigkeit. Die Open-Source-Laufzeitumgebung speichert den Zustand in MemorySaver, der sich im Prozessspeicher befindet. Eine echte Wiederherstellung nach einem Absturz unter Last erfordert die LangGraph Platform in Kombination mit Postgres oder einen eigenen PostgresSaver.
Das OpenAI Agents SDK bietet Sessions für den Konversationszustand sowie Sandbox Agents für Arbeiten mit langfristiger Perspektive, doch es gibt nichts Vergleichbares zu einem Checkpointing auf Knotenebene in einem beliebigen Graphen. Das Claude Agent SDK speichert den JSONL-Konversationszustand lokal oder verwendet Managed Agents für eine gehostete Langzeitverfügbarkeit – auf Kosten von Modellen, die ausschließlich für Claude entwickelt wurden. Derzeit besitzt LangGraph die Fähigkeit zur zuverlässigen Orchestrierung.
Arbeitslast drei: Datei- und Shell-Arbeiten
Der Migrationsskript von dem Entwicklererfahrungsteam muss durch ein 400.000 Zeilen umfassendes Java-Repository gehen, Syntaxänderungen anwenden, Unit-Tests ausführen und Pull Requests erstellen. Das bedeutet das Lesen und Bearbeiten von Dateien, das Ausführen von Shell-Befehlen sowie das Reagieren auf Compilerfehler. Bash und Edit bilden fast die gesamte Arbeitslast.
Das Claude Agent SDK entspricht diesem Konzept direkt, da Anthropics Ziel darin besteht, Agenten einen Computer zur Verfügung zu stellen. Es verfügt über native Tools für Bash, Read, Write, Edit, Glob und Grep, und seine Hooks dienen als Steueroberfläche. Ein Hook vom Typ PreToolUse kann Schutzmaßnahmen gegen zerstörerische Befehle einführen, während ein Hook vom Typ PostToolUse Formater oder Linter ausführen kann. Subagenten teilen die Umwandlungsarbeiten auf isolierte Kontexte auf, sodass ein langer Compiler-Fehlerprotokoll, das an einen Subagenten weitergeleitet wird, das Fenster des Hauptagenten nicht verunreinigt.
# Install: pip install claude-agent-sdk
# Env: export ANTHROPIC_API_KEY=...
import anyio
from claude_agent_sdk import (
ClaudeSDKClient,
ClaudeAgentOptions,
AgentDefinition,
HookMatcher,
)
# PreToolUse hook: block Bash calls that look like rm -rf
async def block_dangerous_bash(input_data, tool_use_id, context):
if input_data.get("tool_name") == "Bash":
cmd = input_data.get("tool_input", {}).get("command", "")
if "rm -rf" in cmd or "rm -rf" in cmd:
return {
"hookSpecificOutput": {
"hookEventName": "PreToolUse",
"permissionDecision": "deny",
"permissionDecisionReason": "rm -rf blocked by policy",
}
}
return {}
# Subagent: runs in isolated context to lint one file
lint_agent = AgentDefinition(
description="Run linters on a single file and return a concise report.",
prompt=(
"You are the lint subagent. Given a file path, run the project's linter "
"on it and return a one-paragraph summary of failures. Do not fix anything."
),
tools=["Bash", "Read"], # Note: tools is deprecated in favor of skills in recent SDKs
)
options = ClaudeAgentOptions(
system_prompt=(
"You are Meridian's code migration agent. Walk the target directory, "
"apply the migration, run tests, and open a PR. Prefer small commits."
),
allowed_tools=["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
hooks={"PreToolUse": [HookMatcher(hooks=[block_dangerous_bash])]},
agents={"lint": lint_agent},
# resume="mig-run-2026-07-06-01", # uncomment to resume a prior session
)
async def main():
async with ClaudeSDKClient(options=options) as client:
await client.query(
"Migrate services/payments/ from Java 17 to Java 21. "
"For every file you touch, delegate to the `lint` subagent afterward. "
"Do NOT commit or open PRs yet. Stop after changes are on disk."
)
async for message in client.receive_response():
print(message)
anyio.run(main)
Die Liste allowed_tools legt die Umgebung des Agents fest. Hooks bieten eine Schutzmaßnahme, die innerhalb des Agentenloops stattfindet und nicht darum herum: Ein Hook namens PreToolUse wird vor der Verwendung eines Tools ausgeführt, und eine Ablehnungsentscheidung stoppt den Aufruf sofort. Der Subagent lint verfügt über seine eigenen Tools sowie ein eigenes Kontextfenster. Neuere SDK-Versionen deprecieren das Feld tools in AgentDefinition zugunsten von skills, obwohl es weiterhin funktioniert. Die kommentierte Zeile im Resume zeigt, wie der Sitzungszustand aus JSONL-Dateien auf der lokalen Festplatte wiederhergestellt wird.
In LangGraph müssten diese Shell-Primitiven als benutzerdefinierte Python-Funktionen geschrieben werden. Die Sandbox Agents des OpenAI SDK laufen in Containern, was in der Architektur ähnlich ist, doch die Primitivensammlung ist nicht auf dieselbe, auf Dateien ausgerichtete Weise benannt oder zugänglich gemacht. Das Problem ist das Modell-Lock-in. Ein Team mit einer strengen Regel gegen Lock-in auf der Modellebene kann das Claude Agent SDK nicht verwenden und muss stattdessen auf LangGraph zurückgreifen, um die bash- und Edit-Primitiven selbst neu zu entwickeln.
Arbeitslast vier: MCP-basierte Orchestrierung
Das Dashboard des Plattformteams beantwortet eine einzige von einem Ingenieur eingegebene Frage. Dahinter holt der Agent Fehler aus Sentry, Tickets aus Linear, Incidents aus PagerDuty sowie Benutzerdaten aus Postgres ab. Fast alle Anstrengungen gehen in die Koordination von Drittanbieter-MCP-Servern, während nur sehr wenig Energie in die Erstellung der Antwort investiert wird.
Hier sind das OpenAI Agents SDK und das Claude Agent SDK auf Augenhöhe. In beiden ist MCP ein zentrales Baustein, und die Server verhalten sich wie lokale Funktionen. LangGraph kann ebenfalls MCP nutzen, erfordert dafür jedoch Mitte 2026 mehr Vorlagencode, und Teams packen die Server in der Regel selbst in Tools ein. Der entscheidende Faktor zwischen den beiden führenden Lösungen ist eine sekundäre Einschränkung.
- Wählen Sie das OpenAI Agents SDK für die eigene Überwachung, strenge Richtlinien sowie die Weitergabe an spezialisierte Unteragenten – oder wenn es attraktiv ist, einfache Syntheseaufgaben über LiteLLM an günstigere Anbieter weiterzuleiten.
- Wählen Sie das Claude Agent SDK für den Lebenszyklus der Hooks, eine strenge Isolierung der Unteragenten sowie die Zuverlässigkeit bei der Nutzung von Tools durch Claude.
Customisierte API-Wrapper für gängige SaaS-Tools verbrauchen viel Entwicklungszeit. Der MCP-Standard standardisiert den Kontext sowie die Entdeckung von Tools, sodass das Framework sich einfach zurückhalten kann, und beide SDKs unterstützen dieses Muster nativ.
Zusammenfassung nach Arbeitslast
- Echtzeit-Sprachkommunikation mit Eingreifen: OpenAI Agents SDK.
- Dauerhafte Mehr-Agenten-Workflows mit menschlicher Freigabe: LangGraph.
- Arbeiten zur Datei-, Shell- und Code-Migration: Claude Agent SDK.
- Intensive MCP-Orchestrierung: OpenAI Agents SDK oder Claude Agent SDK.
Ein Hinweis zu CrewAI
Viele Leser erwarten in einem solchen Vergleich CrewAI. Bei Überprüfung erwies sich die Evidenz für seine aktuelle Version, die Adoption von Flows sowie Unternehmensfallstudien als nicht so solide wie bei den anderen drei, weshalb es weggelassen wurde, anstatt den Artikel mit weniger fundierten Quellen zu füllen.
Die eigentliche Wahl
Vier Agenten wurden auf drei Frameworks implementiert: die Sprach- und Plattform-Agenten im OpenAI SDK, der Rückzahlungsprozess in LangGraph sowie der Migrationsagent im Claude Agent SDK. Über die Frage zu streiten, welches Framework am besten ist, ist der falsche Ansatz. Die Aufgabe besteht darin, die zentralen Primitiven eines Frameworks an die Anforderungen der Aufgabe anzupassen.
Die nächste Runde wird voraussichtlich erneut die Debatte über die Langlebigkeit anstoßen, da LangGraph Platform mit Anthropics Managed Agents konkurriert. LangGraph könnte erstklassige Echtzeit-Primitiven erhalten, oder Anthropic könnte sein SDK für andere Modellanbieter öffnen. Bis dahin bestimmen die Primitiven die Architektur.
Verwandte Artikel
- Ein Multi-Agenten-Router mit LangGraph und einem Überwachungsagenten erstellen — Wie man einen überlasteten Agenten mithilfe eines Überwachungsagenten in LangGraph in Spezialisten aufteilt, unter Verwendung eines vorgefertigten Hilfsprogramms sowie eines manuell erstellten StateGraphs, einschließlich State-Design und häufiger Fehlerquellen in Schleifen.
- Selbstheilendes Multi-Agenten-Team in LangGraph: Architekt, Tester, Debugger — Erstellung einer LangGraph-Zustandsmaschine in Python, in der ein Architekt, Entwickler, pytest-Sandbox, Debugger und Reviewer zusammenarbeiten und Schleifen durchlaufen, bis die Tests bestehen.