AI-Agenten-Frameworks: LangGraph, CrewAI, OpenAI und Claude SDK

Aktualisierung (9. November 2026): Claude Fable 5.2 und Mythos 5.2 sind erschienen - Preise, Zugang und Benchmarks im Überblick zu Claude Fable 5.2.

👁 115 Aufrufe

Ich habe denselben KI-Agenten fünfmal geschrieben: ganz ohne Framework, mit dem OpenAI Agents SDK, LangGraph, CrewAI und dem Claude Agent SDK. Jede Version erhielt dieselben drei Werkzeuge und dieselbe Aufgabe. Gemessen habe ich Codezeilen, Ausführungszeit, Modellaufrufe und Kosten. Die Kurzfassung: Für den Einstieg und einfache Agenten genügen eine eigene Schleife oder das OpenAI Agents SDK, LangGraph überzeugt bei komplexen Workflows, CrewAI bei Multi-Agenten-Teams mit festen Rollen und das Claude Agent SDK glänzt bei dateibasierten Workflows wie in Claude Code. Dieser Beitrag gehört zur Reihe KI-Agenten von Grund auf.

Die Testaufgabe

Der Agent soll ermitteln, wie hoch die Ausgaben aus Rechnungsdateien im Ordner dane/ waren (zwei Rechnungen in Fremdwährung, eine über 120 EUR), wobei ein tagesaktueller Wechselkurs über eine API abgefragt werden muss. Das Zielergebnis lautet 3919,74 Einheiten. Die Werkzeuge sind für alle Versionen identisch und in einer separaten Datei ausgelagert. Hinweis: Der Test wurde im polnischen Originalumfeld mit polnischen Rechnungen und API-Vorgaben durchgeführt; die nachfolgenden Code- und Prompt-Auszüge sind deutsche Übersetzungen:

• dateien_suchen: liest den Text der .txt-Dateien aus dem Ordner;
• rechner: sichere Auswertung mathematischer Ausdrücke;
• webseite_lesen: Abruf einer Webseite oder API-Antwort.

"""Gemeinsame Werkzeuge für alle Agentenversionen (Standard-Python-Funktionen, ohne Framework). Übersetzung des polnischen Originaltests."""
import ast, operator, pathlib
import requests
from bs4 import BeautifulSoup

KATALOG = (pathlib.Path(__file__).parent.parent / "dane").resolve()
ZADANIE = ("Berechne, wie viel insgesamt für Rechnungen im Ordner 'dane' ausgegeben wurde. "
           "Rechne die Euro-Rechnung zum heutigen NBP-Kurs um.")
INSTRUKCJA = ("Löse die Aufgabe mit Werkzeugen. Wechselkurse: https://api.nbp.pl/api/exchangerates/rates/a/{kod}/?format=json. "
              "Rechnungen immer mit dem Rechner durchführen. Antworte kurz.")

def dateien_suchen(suchbegriff: str = "") -> str:
    """Zeigt .txt-Dateien aus dem Ordner dane/ und deren Inhalt. Leerer Suchbegriff = alle Dateien."""
    out = [f"== {p.relative_to(KATALOG)} ==n{p.read_text(encoding='utf-8')[:1500]}"
           for p in sorted(KATALOG.rglob("*.txt")) if suchbegriff.lower() in p.read_text(encoding="utf-8").lower()]
    return "n".join(out) or "keine Dateien gefunden"

OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.USub: operator.neg}
def rechner(ausdruck: str) -> str:
    """Berechnet einen arithmetischen Ausdruck, z. B. 2214+1180.8."""
    def rechne(n):
        if isinstance(n, ast.Constant): return n.value
        if isinstance(n, ast.BinOp): return OPS[type(n.op)](rechne(n.left), rechne(n.right))
        if isinstance(n, ast.UnaryOp): return OPS[type(n.op)](rechne(n.operand))
        raise ValueError("nur Zahlen und + - * /")
    return str(round(rechne(ast.parse(ausdruck, mode="eval").body), 4))

def webseite_lesen(url: str) -> str:
    """Ruft den Text einer Website oder eine API-Antwort unter der URL ab."""
    r = requests.get(url, timeout=20, headers={"User-Agent": "agenten-starter/1.0"})
    return BeautifulSoup(r.text, "html.parser").get_text(" ", strip=True)[:4000]

Auf diese Weise wird ausschließlich der Framework-Overhead gemessen und nicht die Werkzeuglogik selbst. Wie eine Agentenschleife im Detail aufgebaut ist, erläutere ich Schritt für Schritt im Artikel Wie man einen KI-Agenten in Python baut.

Messergebnisse

Kosten umgerechnet zum EZB-Kurs vom 12.10.2026 (1 EUR = 1,1181 USD, Quelle: https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml).

Berechnungsgrundlagen:

• Codezeilen: nicht-leere Zeilen ohne Kommentare, exklusive der gemeinsamen Werkzeugdatei;
• Zeit: vom Start des Python-Prozesses bis zur Ausgabe, inklusive Bibliotheksimport. Durchschnitt aus 3 Durchläufen;
• Pakete: Anzahl der Abhängigkeiten, die pip für das Framework installiert (Dependency Resolution unter Python 3.13);
• Kosten: Summe des Feldes cost, das OpenRouter bei jedem Aufruf zurückgibt.

Zentrale Erkenntnisse:

• Bei einem einfachen Agenten beeinflusst das Framework die Kosten kaum. Die GPT-5.6-Luna-Versionen liegen zwischen ca. 0,00054 EUR und 0,00080 EUR (0,0006 und 0,0009 USD). Das OpenAI Agents SDK und CrewAI führten gelegentlich einen vierten Schritt aus (separate Aufrufe des Rechners), was den Schnitt minimal anhebt.
• Das Claude Agent SDK ist spürbar teurer und langsamer, was primär am Modell liegt. Der Kontrolllauf zeigt den Unterschied: Haiku in der eigenen Schleife kostete ca. 0,0063 EUR (0,0071 USD), im Claude Agent SDK ca. 0,0133 EUR (0,0149 USD). Rund die Hälfte des Aufpreises entsteht durch die Claude-Code-Engine (umfangreichere System-Prompts, Denkprozess vor jedem Schritt).
• CrewAI zieht die meisten Abhängigkeiten nach (137 Pakete, ca. 790 MB Installationsgröße) und benötigt die längste Importzeit. Hier empfiehlt sich eine isolierte virtuelle Umgebung.

1. Ohne Framework: 16 Zeilen

import json, os
from openai import OpenAI
from narzedzia import ZADANIE, INSTRUKCJA, dateien_suchen, rechner, webseite_lesen

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"])
FUNKTIONEN = {f.__name__: f for f in (dateien_suchen, rechner, webseite_lesen)}
TOOLS = [{"type": "function", "function": {"name": n, "description": f.__doc__, "parameters": {"type": "object",
          "properties": {p: {"type": "string"} for p in f.__annotations__ if p != "return"}}}} for n, f in FUNKTIONEN.items()]

messages = [{"role": "system", "content": INSTRUKCJA}, {"role": "user", "content": ZADANIE}]
for schritt in range(8):
    msg = client.chat.completions.create(model=os.environ["MODEL"], messages=messages, tools=TOOLS).choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    if not msg.tool_calls:
        print(msg.content); break
    for c in msg.tool_calls:
        ergebnis = FUNKTIONEN[c.function.name](**json.loads(c.function.arguments or "{}"))
        messages.append({"role": "tool", "tool_call_id": c.id, "content": ergebnis})

Hier liegt alles offen: Nachrichtenverlauf, Ausführungsschleife und Funktionsaufrufe. Die Werkzeugdefinitionen werden dynamisch aus Docstrings erzeugt. Es fehlen Logging, Retries bei Netzwerkfehlern und Validierung fehlerhafter Argumente. In einem Produktivprojekt kommen dafür etwa 30 bis 50 Zeilen hinzu, wie in der vollständigen Agenten-Anleitung gezeigt.

2. OpenAI Agents SDK: 10 Zeilen

import os
from openai import AsyncOpenAI
from agents import Agent, OpenAIChatCompletionsModel, Runner, function_tool, set_tracing_disabled
from narzedzia import ZADANIE, INSTRUKCJA, dateien_suchen, rechner, webseite_lesen

set_tracing_disabled(True)
model = OpenAIChatCompletionsModel(model=os.environ["MODEL"], openai_client=AsyncOpenAI(
    base_url="https://openrouter.ai/api/v1", api_key=os.environ["OPENROUTER_API_KEY"]))
agent = Agent(name="Rechnungen", instructions=INSTRUKCJA, model=model,
              tools=[function_tool(f) for f in (dateien_suchen, rechner, webseite_lesen)])
print(Runner.run_sync(agent, ZADANIE, max_turns=8).final_output)

Der kompakteste Ansatz. function_tool generiert das Schema direkt aus der Funktionssignatur, Runner.run_sync steuert die Schleife inklusive Abbruchbedingung über max_turns. Zudem stehen Features wie Agenten-Handoffs, Guardrails, Sitzungsverwaltung und Tracing bereit. Bei OpenRouter muss Tracing deaktiviert und der Client in OpenAIChatCompletionsModel gewrappt werden, da das SDK standardmäßig auf die Responses API von OpenAI ausgelegt ist.

3. LangGraph: 19 Zeilen

import os
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.prebuilt import ToolNode, tools_condition
from narzedzia import ZADANIE, INSTRUKCJA, dateien_suchen, rechner, webseite_lesen

werkzeuge = [dateien_suchen, rechner, webseite_lesen]
llm = ChatOpenAI(model=os.environ["MODEL"], base_url="https://openrouter.ai/api/v1",
                 api_key=os.environ["OPENROUTER_API_KEY"]).bind_tools(werkzeuge)

def model(state: MessagesState):
    return {"messages": [llm.invoke(state["messages"])]}

graph = StateGraph(MessagesState)
graph.add_node("model", model)
graph.add_node("tools", ToolNode(werkzeuge))
graph.add_edge(START, "model")
graph.add_conditional_edges("model", tools_condition)  # Gibt es Tool Calls? -> "tools", sonst -> END
graph.add_edge("tools", "model")
agent = graph.compile()

ergebnis = agent.invoke({"messages": [("system", INSTRUKCJA), ("user", ZADANIE)]}, {"recursion_limit": 16})
print(ergebnis["messages"][-1].content)

Der umfangreichste Code, da der Graph hier bewusst manuell konstruiert wurde. Dies verdeutlicht das LangGraph-Konzept: State (Nachrichtenliste), Knoten (Modell, Werkzeuge) und Kanten (Bedingungen zur Tool-Ausführung). Für einen simplen Agenten ist das überdimensioniert. Bei Workflows mit Verzweigungen, Human-in-the-Loop-Freigaben, State Persistence und Wiederanlauf nach Fehlern zahlt sich diese Architektur jedoch direkt aus. Die maximale Schrittanzahl wird über recursion_limit festgelegt.

4. CrewAI: 10 Zeilen

import os
from crewai import Agent, Task, Crew, LLM
from crewai.tools import tool
from narzedzia import ZADANIE, INSTRUKCJA, dateien_suchen, rechner, webseite_lesen

llm = LLM(model="openrouter/" + os.environ["MODEL"], base_url="https://openrouter.ai/api/v1",
          api_key=os.environ["OPENROUTER_API_KEY"])
buchhalter = Agent(role="Buchhalter", goal="Ausgaben aus Rechnungen berechnen", backstory=INSTRUKCJA, llm=llm,
                   tools=[tool(f) for f in (dateien_suchen, rechner, webseite_lesen)], max_iter=8, verbose=False)
aufgabe = Task(description=ZADANIE, expected_output="Gesamtsumme mit kurzer Berechnung", agent=buchhalter)
print(Crew(agents=[buchhalter], tasks=[aufgabe]).kickoff().raw)

CrewAI arbeitet rollenbasiert: Ein Agent besitzt Rolle, Ziel und Hintergrundgeschichte, während Aufgaben eine Beschreibung und ein erwartetes Ausgabeformat verlangen. Für einen Einzelagenten ist das viel semantischer Overhead. In Multi-Agenten-Szenarien (Rechercheur beschafft Daten, Redakteur formuliert, Prüfer kontrolliert) ist das Paradigma dafür sehr anschaulich. Das Modell wird mit Provider-Präfix (hier openrouter/) übergeben. CrewAI setzt Python 3.10 bis 3.13 voraus.

5. Claude Agent SDK: 24 Zeilen

import asyncio, os
from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, create_sdk_mcp_server, query, tool
from narzedzia import ZADANIE, INSTRUKCJA, dateien_suchen, rechner, webseite_lesen

def wrap_tool(f, param):  # Python-Funktion -> SDK-Werkzeug (liefert Textblöcke)
    @tool(f.__name__, f.__doc__, {param: str})
    async def t(args):
        return {"content": [{"type": "text", "text": f(args.get(param, ""))}]}
    return t

server = create_sdk_mcp_server("rechnungen", tools=[wrap_tool(dateien_suchen, "suchbegriff"),
                                                     wrap_tool(rechner, "ausdruck"),
                                                     wrap_tool(webseite_lesen, "url")])
optionen = ClaudeAgentOptions(system_prompt=INSTRUKCJA, model=os.environ.get("CLAUDE_MODEL", "anthropic/claude-haiku-4.5"),
                              mcp_servers={"rechnungen": server}, strict_mcp_config=True,
                              tools=[],  # Eingebaute Claude-Code-Tools (Bash, Edit etc.) deaktivieren
                              allowed_tools=["mcp__rechnungen__dateien_suchen", "mcp__rechnungen__rechner",
                                             "mcp__rechnungen__webseite_lesen"], max_turns=8,
                              cli_path=os.getenv("CLAUDE_CLI"),  # Windows: Pfad zu claude.exe (nicht claude.cmd)
                              setting_sources=[],  # Keine ~/.claude/settings.json laden (mögliche URL-Konflikte)
                              env={"ANTHROPIC_BASE_URL": "https://openrouter.ai/api",  # Claude über OpenRouter
                                   "ANTHROPIC_AUTH_TOKEN": os.environ["OPENROUTER_API_KEY"], "ANTHROPIC_API_KEY": ""})

async def main():
    async for m in query(prompt=ZADANIE, options=optionen):
        if isinstance(m, ResultMessage):
            print(m.result)
asyncio.run(main())

Der Konfigurationsaufwand ist hier am höchsten, da das SDK im Grunde Claude Code als Bibliothek kapselt. Eigene Funktionen werden als In-Memory-MCP-Server (create_sdk_mcp_server) registriert. Die Standardwerkzeuge (Bash, Datei-Editor) wurden über tools=[] abgeschaltet. Wichtige Fallstricke aus der Praxis:

• Unter Windows verweigert das SDK den Aufruf der npm-Wrapperdatei claude.cmd. Der direkte Pfad zu claude.exe muss zwingend in cli_path hinterlegt werden.
• Ohne setting_sources=[] las das SDK bestehende Konfigurationen aus ~/.claude/settings.json aus und sendete Abfragen an einen abweichenden Endpoint (Fehler 403).
• Bei der Nutzung über OpenRouter verbindet sich Claude Code mit der Anthropic-kompatiblen Schnittstelle (ANTHROPIC_BASE_URL=https://openrouter.ai/api), wobei der Token in ANTHROPIC_AUTH_TOKEN übergeben wird.

Vergleich: Welches Framework für welches Szenario?

Neben diesen Bibliotheken existieren weitere Lösungen am Markt: Google bietet das ADK (Agent Development Kit, Version 2.11.0 auf PyPI), Hugging Face pflegt smolagents (1.26.0) und Microsoft entwickelt das Agent Framework. Diese wurden im vorliegenden Test nicht gemessen. Wer No-Code bevorzugt, findet vergleichbare Konzepte in n8n (AI-Agent-Knoten) oder Gumloop.

Praxis-Empfehlung

1. Bauen Sie den ersten Agenten ohne jedes Framework. Ein investierter Nachmittag spart später viel Zeit bei der Fehlersuche in fremden Abstraktionen.
2. Für das erste reguläre Projekt empfiehlt sich das OpenAI Agents SDK: Es harmoniert mit OpenRouter sowie lokalen Modellen und erfordert minimalen Boilerplate-Code.
3. Wählen Sie LangGraph, sobald Sie anfangen, Kontrollflüsse mit Verzweigungen, Bedingungen und Schleifen aufzuzeichnen.
4. CrewAI und das Claude Agent SDK eignen sich ideal für spezialisierte Nischen: Rollenteams oder tiefe Dateisystemoperationen.

Häufige Fragen (FAQ)

LangChain oder LangGraph?

LangChain liefert Basiskomponenten wie Modell-Clients, Tool-Wrapper und Parser. LangGraph übernimmt die Ablaufsteuerung über Graphen. In Version 1.x nutzt LangChain für Agenten intern LangGraph. Für Agentenprojekte sollten Sie direkt mit LangGraph beginnen und LangChain lediglich für spezifische Integrationen (etwa langchain-openai) heranziehen.

Sind KI-Agenten-Frameworks kostenlos nutzbar?

Alle fünf getesteten Bibliotheken sind quelloffen und kostenfrei. Kosten fallen für die genutzten Modell-Token an. Kostenpflichtig sind in der Regel optionale Cloud-Dienste wie LangSmith (Tracing für LangGraph) oder Enterprise-Plattformen der Anbieter.

Welches Framework unterstützt lokale Modelle?

Der native Python-Loop, das OpenAI Agents SDK, LangGraph und CrewAI lassen sich problemlos an Ollama über die OpenAI-kompatible Schnittstelle anbinden. Das Claude Agent SDK verlangt zwingend Modelle von Anthropic.

Verbessert ein Framework die Ausgabequalität?

Im durchgeführten Benchmark war das nicht der Fall: Alle Varianten lieferten exakt dasselbe Resultat. Die Qualität hängt von der Modellwahl, den System-Prompts, den Tool-Beschreibungen und den Eingabedaten ab. Ein Framework steuert lediglich Ablauf, Struktur und Tracing.

Wie teuer waren die Testläufe?

Die 16 Durchläufe (15 Messläufe plus ein Kontrolllauf) verursachten Gesamtkosten von ca. 0,054 EUR (0,060 USD), wovon ca. 0,046 EUR (0,052 USD) allein auf die Claude-Haiku-Tests entfielen (EZB-Referenzkurs vom 12.10.2026: 1 EUR = 1,1181 USD).

Wo lässt sich die Arbeit mit den Frameworks vertiefen?

Kostenfreie Lernressourcen bieten die LangChain Academy (Intro to LangGraph), DeepLearning.AI (AI Agents in LangGraph, Multi AI Agent Systems with crewAI) sowie die offiziellen Dokumentationen des OpenAI Agents SDK und Claude Agent SDK. Eine Übersicht finden Sie in unserer Ressourcensammlung.

Quellen und Prüfdatum

• OpenAI Agents SDK, LangChain Academy: Intro to LangGraph, CrewAI-Dokumentation, Claude Agent SDK (geprüft am 4.10.2026).
• Paketversionen: PyPI, 4.10.2026.
• Messungen: Lokales Testsystem (Windows 11, Python 3.13), 4. Oktober 2026, 13:53-13:57 Uhr. Der Code liegt im Repository unter frameworki/.

// weiterlesenOpenAI-Agenten griffen im Mai RubyGems an und versuchten, API-Schlüssel zu stehlenNachrichtenKI-Agenten außer Kontrolle: Der Sommer 2026 bei OpenAIMagazinOpenAI Dots: KI-Agenten mit eigenem Computer in der CloudKI-Werkzeuge

Kinetyra