Vergleich von sechs Python-AI-Agent-Frameworks durch die Erstellung desselben Agenten.
Derselbe Forschungsagent, der in LangGraph, CrewAI, PydanticAI, OpenAI Agents SDK, Smolagents und Google ADK implementiert ist, mit Linien, Tokens, Debug-Werten und einer Auswahlhilfe.
Fragen Sie eine Gruppe, welches Agent-Framework man verwenden soll, und Sie erhalten Dutzende selbstbewusster, widersprüchlicher Antworten. Eine Fraktion bezeichnet LangGraph als überdimensioniert. Eine andere hält es für die einzige ernsthafte Option. Eine dritte rät, Frameworks ganz zu meiden und direkt mit der Modell-API zu arbeiten. Ein Klientenprojekt macht solche Diskussionen teuer, daher ist der praktische Ausweg, auf Streitigkeiten zu verzichten und ein Experiment durchzuführen.
Das Experiment war einfach: Innerhalb eines Wochenendes wurde derselbe Agent in sechs Python-Frameworks mit derselben Aufgabe, demselben Modell, denselben Werkzeugen und derselben Bewertungsmethode entwickelt. Das zugrundeliegende Projekt war im Sinne von 2026 ein Dokumentenanalyse-Pipeline, was bedeutet, Daten aus PDFs zu extrahieren, sie mit einer Datenbank abzugleichen, eine Zusammenfassung zu schreiben und das Ergebnis per E-Mail zu versenden. Die Ergebnisse schmeicheln keiner der lautstarken Fraktionen.
Was entwickelt wurde und wie es bewertet wurde
Der Test-Agent nimmt einen Firmennamen entgegen, sucht aktuelle Nachrichten im Internet, extrahiert wichtige finanzielle Kennzahlen, vergleicht sie mit einer lokalen SQLite-Datenbank und gibt eine strukturierte JSON-Zusammenfassung zurück. Das sind drei Tools, ein Agent und ein Ausgabeschema.
Es ist absichtlich langweilig. Fast niemand bringt einen autonomen Programmier-Agenten als erstes Produktivsystem auf den Markt. Die meisten tatsächlichen Agentenlösungen sind API-Orchestratoren mit etwas zusätzlichem Reasoning, und jedes Framework sollte das problemlos bewältigen können. GPT-4o diente als Modell, wo immer ein Framework dies zuließ.
Fünf Aspekte wurden gemessen:
- benötigte Zeilen an Code
- Token pro Ausführung, durchschnittlich über 10 Ausführungen
- Durchschnittliche Latenz
- Stunden von Null bis zu einem funktionsfähigen Prototypen
- eine „2 AM Debug Score“, also wie leicht man herausfinden kann, was schiefgelaufen ist, wenn der Prozessspool spät in der Nacht ausfällt
Diese letzte Kennzahl ist wichtiger, als es scheint. Dinge gehen immer kaputt.
LangGraph: für Menschen, die Kontrolle mögen
Ungefähr 210 Zeilen. Drei Stunden bis zu einem funktionsfähigen Agenten. 2.847 Tokens pro Ausführung.
LangGraph wirkt, als wäre es von Ingenieuren für verteilte Systeme entworfen worden. Man deklariert den Zustand, definiert Knoten, zieht Kanten zwischen ihnen und kompiliert das Ergebnis. Es erinnert weniger an den Aufbau eines KI-Agenten und eher an die Gestaltung eines Datenpipelines – was ein Kompliment ist.
Die erste Stunde ist schwierig. StateGraph, add_node und add_conditional_edges für einen dreifach-funktionalen Agenten erscheinen als viel zu viele Formalitäten, wodurch der Drang entsteht, zum nächsten Kandidaten überzugehen.
Dann ändert ein Fehler das Bild. Bei der dritten Testanfrage funktionierte der Agent sehr schlecht, und das Öffnen von LangSmith zeigte den gesamten Ablauf Schritt für Schritt: Welcher Knoten die falsche Entscheidung traf, welchen Zustand er hatte und warum das Tool zur Datenbank vor der Suche aufgerufen wurde. Nur wenige Frameworks ermöglichen eine derart direkte Diagnose.
Die Funktion, die die Leute selten erwähnen: dauerhafte Ausführung. Eine abgestürzte Ausführung setzt an ihrem letzten Checkpoint fort. Bei einem Experiment am Wochenende ist das angenehm. Bei einem Pipeline-Prozess, der über Nacht 10.000 Dokumente verarbeitet, entscheidet das darüber, ob man schlafen kann oder um 3 Uhr morgens geweckt wird.
LangGraph verwendete außerdem bei dem Test die wenigsten Tokens. Da der Graph den Kontrollfluss darstellt, muss das Modell keine Tokens dafür aufwenden, zu entscheiden, was als Nächstes kommt – man hat es ihm bereits mitgeteilt.
Die Kosten entstehen durch vorweggenommenes Denken. Es gibt keine Anleitungen zum Einfügen und Hoffen. Ein gut definiertes Problem belohnt eine strukturierte Herangehensweise – doch wenn man sich noch mit dem Arbeitsablauf auseinandersetzt, zeichnet man mehr Diagramme, als man tatsächlich Funktionen veröffentlicht.
Debug-Bewertung um 2 Uhr morgens: 9/10. LangSmith hat seinen guten Ruf verdient, und Probleme konnten hier schneller diagnostiziert werden als anderswo.
CrewAI: die Maschine für schnelle Prototypen
Etwa 340 Zeilen. 45 Minuten bis zu einem funktionsfähigen Agenten. 4.216 Tokens pro Ausführung.
Von pip install crewai bis zum korrekten Ergebnis vergingen drei Viertelstunden – das schnellste Startverhalten abgesehen von Smolagents.
CrewAI denkt in Teams, nicht in einzelnen Agenten. Jedes Mitglied erhält eine Rolle, ein Ziel und eine Hintergrundgeschichte; Aufgaben werden der Gruppe zugewiesen, und die Mitglieder entscheiden, wer was erledigt.
researcher = Agent(
role="Financial Research Analyst",
goal="Find and verify recent financial data",
backstory="You're a senior analyst at a hedge fund...",
)
Das Feld für die Hintergrundgeschichte wirkt wie ein Trick und wurde mit einem Augenrollen aufgenommen. Dennoch waren die Ausgaben des CrewAI-Agenten deutlich detaillierter als bei derselben Anfrage, die über reine API-Aufrufe gesendet wurde – somit verändert die Rollenzuweisung tatsächlich, wie das Modell die Aufgabe angeht.
Schnelligkeit hat ihren Preis. CrewAI verbrauchte für dieselbe Aufgabe etwa 48 Prozent mehr Token als LangGraph. Die Architektur setzt voraus, dass mindestens zwei oder drei Agenten zusammenarbeiten; selbst eine Kombination aus Forscher und Schreiber, eine Aufgabe, die ein einziger Agent bewältigen könnte, erfordert aufgrund der Delegation zusätzliche Ressourcen. Zudem arbeitet das System im synchronen Modus, weshalb die Integration in einen asynchronen FastAPI-Backend erforderte, dass die Aufrufe in run_in_executor eingebettet werden mussten. Das ist zwar erträglich, aber äußerst nervig.
Die Kosten steigen schnell an. Eine veröffentlichte Vergleichsstudie ergab Kosten von 1.088 Dollar für CrewAI im Test gegenüber 390 Dollar für eine äquivalente PydanticAI-Lösung. Wenn der Agent täglich tausende Male ausgeführt wird, wächst der Unterschied weiter an.
Auf der Fehlerbehebungsskala erhält es um 2 Uhr morgens 5/10 Punkte. Erfolge sind wunderbar, doch Fehler verschwinden in einer Delegationskette, die sich wie eine Black Box verhält. Ein Fehler kostete 40 Minuten, bevor klar wurde, dass es zwei Agenten waren, die dieselbe Aufgabe hin und her weitergaben.
PydanticAI: der leise Überflieger
Etwa 130 Zeilen. 1,5 Stunden bis zu einem funktionsfähigen Agenten. 2.912 Tokens pro Ausführung.
Während LangGraph für diejenigen geeignet ist, die Kontrolle suchen, und CrewAI für die Ungeduldigen, eignet sich PydanticAI für Entwickler, die wollen, dass der Code bereits nach sechs Monaten sinnvoll funktioniert. Das Pydantic-Team hat es entwickelt, und jeder, der bereits FastAPI verwendet hat, kennt bereits die Hälfte der API. Die Agenten sind typisiert, die Ausgaben werden überprüft und Abhängigkeiten werden injiziert – somit wird alles erfasst, was vor der Ausführung behoben werden kann.
agent = Agent(
"openai:gpt-4o",
result_type=CompanyAnalysis, # Pydantic model
system_prompt="You are a financial research assistant.",
)
Das Argument result_type leistet mehr, als es auf den ersten Blick scheint. Jede Antwort des Modells wird automatisch mit Ihrem Schema abgeglichen. Wenn das Modell fehlerhaft formatierten JSON zurückgibt – was letztendlich immer der Fall ist – fängt das Framework dies ab und versucht es erneut, wodurch kein manuell geschriebener Validierungscode erforderlich ist.
Das Projekt full-stack-ai-agent-template führte einen kontrollierten Vergleich durch, der dieses Muster widerspiegelt. Dasselbe Chat-Programm benötigte etwa 160 effektive Zeilen in PydanticAI, rund 280 in LangGraph und ungefähr 420 in CrewAI.
Kürzerer Code ist nicht automatisch besser, doch hier wurde untersucht, wie schnell jede Version verstanden werden konnte. Die Version von PydanticAI ließ sich Zeile für Zeile lesen und erfassen. Die Version von LangGraph erforderte es, den Graphen mental nachzuvollziehen, während die Version von CrewAI ein Verständnis des Delegationsmodells erforderte.
Die Einschränkung besteht darin, dass PydanticAI ein Framework für einzelne Agenten ist. Es verfügt weder über eingebaute Multi-Agenten-Orchestrierung noch über Funktionen zur Übertragung von Aufgaben oder Delegation, sodass ein dreifach-Agenten-Design bedeutet, dass man die Koordination selbst schreiben muss. Das pydantic-graph-Modul existiert zwar, erreicht aber bei komplexen Workflows noch nicht das Niveau von LangGraph oder CrewAI.
Das Debuggen spät in der Nacht erhält eine Bewertung von 8/10. Typfehler werden früh sichtbar, die IDE weist Probleme bereits vor dem Ausführen auf und die Stack-Traces zeigen die richtige Zeile an.
OpenAI Agents SDK: der Geheimtipp
Etwa 150 Zeilen. Eine Stunde bis zu einem funktionsfähigen Agenten. 2.791 Tokens pro Ausführung.
Ein Framework vom Modellanbieter klingt nach einer Art „Lock-in“-Lösung, und es wäre beinahe aus dem Test ausgeschlossen worden. Diese Erwartung erwies sich jedoch als falsch.
Das SDK ist OpenAI’s produktionsreife Neuauflage seines früheren Swarm-Experiments und reduziert sich auf vier Grundelemente: Agenten, Übertragungen, Werkzeuge und Schutzmechanismen. Die Übertragungen sind dabei besonders hervorzuheben. Man legt fest, welche Agenten Aufgaben an welche anderen weitergeben dürfen, und das Framework kümmert sich um die Weiterleitung. Es ist weniger flexibel als LangGraphs Graphenmodell, reicht aber für etwa 80 Prozent der Mehr-Agenten-Anwendungsfälle aus und ist zudem viel einfacher.
agent = Agent(
name="Researcher",
instructions="You are a financial research assistant.",
tools=[search_tool, db_tool],
handoffs=[summary_agent],
)
Es ist außerdem nicht mehr an einen einzigen Anbieter gebunden. Die Unterstützung für mehr als 100 LLMs wird über einen any-llm-Adapter bereitgestellt, und derselbe Test wurde ohne Codeänderungen mit Claude durchgeführt.
Die Token-Effizienz entspricht der von LangGraph und liegt damit am niedrigsten im Test. Die eingebaute Trace-Funktion ist solide, liegt jedoch etwas unter der von LangSmith.
Der Nachteil ist ein kleineres Ökosystem. LangGraph verfügt über jahrelange Community-Tools, Tutorials und bewährte Muster. Hier ist das Produkt neuer, sodass man bei Randfällen oft allein dasteht.
Debug-Score um 2 Uhr morgens: 7/10. Die Trace-Funktion ist eingebaut und nützlich, und Fehler sind klar erkennbar. Dokumentationslücken erfordern jedoch häufigeres Lesen des Quellcodes, als man gerne hätte.
Smolagents: Die Wahl der Minimalisten
Etwa 95 Zeilen. 30 Minuten bis zu einem funktionsfähigen Agenten. 3.340 Token pro Ausführung.
Die Zahlen sind kein Tippfehler. Hugging Face nimmt den Minimalismus ernst – die Kernlogik umfasst etwa 1.000 Zeilen Python, die man bereits am Nachmittag durchlesen kann. Das lässt sich bei LangGraph nicht behaupten.
Der Unterschied liegt nicht nur im Umfang. Alle anderen Frameworks hier nutzen JSON-basierte Aufrufe, wobei der Agent einen Datensatz sendet, der angibt, welche Funktion mit welchen Argumenten ausgeführt werden soll. Smolagents’ CodeAgent hingegen schreibt echten Python-Code.
agent = CodeAgent(
tools=[search_tool, db_tool],
model=InferenceClientModel(),
)
result = agent.run("Analyze recent financial news for Acme Corp")
Durch das Schreiben von Code können Agenten Tools auf natürliche Weise kombinieren, unter Verwendung von Schleifen, bedingten Anweisungen sowie aufeinander aufbauenden Operationen, die JSON-Aufrufe nicht darstellen können. Benchmark-Forschungen bestätigen dies, da Code-Agenten in den meisten Tests besser abschneiden als JSON-basierte Agenten.
Der Kompromiss liegt in der Sicherheit, da der Agent Python generiert und ausführt. Sandboxing ist über E2B, Docker und Pyodide verfügbar, muss jedoch selbst eingerichtet werden. Der Standardwert LocalPythonExecutor ist ausdrücklich keine Sicherheitsbarriere, wie in seiner Dokumentation erwähnt wird.
Der Tokenverbrauch lag höher als bei LangGraph und dem OpenAI SDK. Der generierte Python-Code ist im Vergleich zum kompakten JSON umfangreicher, und jede Import-Anweisung sowie jede Variabledeklaration kostet Tokens.
Mit Gemini oder GPT funktioniert es einwandfrei, aber es wirkt wie ein passender Stift in ein falsches Loch. Es glänzt mit den Modellen und der Infrastruktur von Hugging Face, und die Integration in den Hub, die Agenten genauso teilt und lädt wie Modelle, ist hervorragend, wenn man bereits in diesem Ökosystem tätig ist.
Debug-Bewertung um 2 Uhr morgens: 8/10. Das Lesen des von einem Agenten geschriebenen Codes ist besser als die Dekodierung einer Kette von JSON-Toolaufrufen, und bei Fehlern wird ein gewöhnlicher Python-Traceback angezeigt.
Google ADK: das Geheimtipp unter den Unternehmenslösungen
Etwa 180 Zeilen. Zwei Stunden bis zu einem funktionsfähigen Agenten. 3.102 Tokens pro Ausführung.
Googles Agent Development Kit tauchte 2025 leise auf, und viele Python-Entwickler haben es noch nie ausprobiert. Das ist eine Lücke, die geschlossen werden sollte.
ADK ist in Bezug auf die Struktur festgelegt, aber bei der Umsetzung flexibel – genau wie Googles interne Tools üblicherweise sind. Agenten werden mit einem Modell, einem Namen, Anweisungen und Tools definiert, ähnlich wie beim OpenAI SDK. Darauf aufbauend gibt es Workflow-Agenten (sequentiell, parallel und in Schleifen) sowie die neuere AgentTeam-API zur Koordination mehrerer Agenten.
from google.adk.agents import Agent
root_agent = Agent(
model="gemini-2.5-flash",
name="financial_analyst",
instruction="You are a financial research assistant.",
tools=[search_tool, db_tool],
)
Das Bewertungssystem ist es, was es von anderen unterscheidet. Testfälle werden als JSON geschrieben, adk eval führt sie aus, und man erhält strukturierte Berichte darüber, ob das Verhalten den Erwartungen entspricht. Kein anderes Framework im Angebot bietet eine so ausgereifte Bewertungstooling-Lösung.
Auch die Bereitstellung verläuft reibungslos, vorausgesetzt, man nutzt Google Cloud. Der Vertex AI Agent Engine kümmert sich um Skalierung, Überwachung und Sitzungen – doch diese Voraussetzung ist von großer Bedeutung.
ADK ist auf Gemini abgestimmt. Andere Modelle funktionieren über LiteLLM, doch die Dokumentation, Beispiele sowie Tools gehen alle von Gemini aus. Beim Einsatz von GPT-4o traten un dokumentierte Randfälle auf, die erst nach 45 Minuten gelöst werden konnten.
Debug-Bewertung um 2 Uhr morgens: 6/10. Die adk web Dev-UI hilft dabei. Allerdings sind die Fehlermeldungen manchmal rätselhaft, und die Dokumentation ist auf typische Google-Art umfangreich, was eine schwierige Navigation bedeutet.
Welches soll man wählen?
„Es hängt davon ab“ frustriert alle – daher hier die Entscheidungslogik, die sich aus dem sechsfachen Aufbau des Agenten ergeben hat:
- Produktionsstart bis Freitag: Wählen Sie CrewAI oder Smolagents. CrewAI eignet sich für Teams, die mit der Fehlersuche bei der Ausführung von Python-Code Schwierigkeiten haben. Smolagents ist besser für Teams, die damit umgehen können und eine möglichst geringe Abhängigkeitslast wünschen.
- Muss monatelang zuverlässig laufen: Wählen Sie LangGraph oder PydanticAI. LangGraph eignet sich für branchenbasierte Logik, Schritte mit menschlicher Einmischung sowie für eine langlebige Ausführung. PydanticAI ist vor allem für Arbeiten mit einem einzelnen Agenten und strukturierten Ausgaben geeignet, bei denen zukünftige Leser den Code verstehen sollten.
- Sind bereits in ein bestimmtes Ökosystem eingebunden: Wählen Sie das OpenAI Agents SDK auf OpenAI’s Plattform wegen seiner Überwachungs- und Bewertungsfunktionen oder das Google ADK auf GCP für eine native Integration in Vertex AI mit integrierten Bewertungen.
Das Unangenehme ist, dass bei den meisten Projekten das Framework weniger wichtig ist als Prompt-Engineering und Tool-Design. Die Ausgabequalität war bei allen sechs Ansätzen fast identisch, sobald dem System-Prompt und den Tool-Beschreibungen wirklich Aufmerksamkeit geschenkt wurde. Was sich unterschied, waren die Entwicklererfahrung, die Fehlersuche sowie die Betriebskosten.
Die in der Produktion überlebende Konfiguration: PydanticAI für Einzel-Agenten-Aufgaben, die den größten Teil der Arbeit ausmachen, sowie LangGraph, wenn der Workflow tatsächlich komplex ist. Es gibt keinen Grund, sich dafür zu entschuldigen, zwei Frameworks zu verwenden.
Alle sechs nebeneinander
| Metric | LangGraph | CrewAI | PydanticAI | OpenAI SDK | Smolagents | Google ADK |
| ----------------- | ----------- | --------------- | ------------- | ---------------- | --------------- | --------------- |
| Lines of code | ~210 | ~340 | ~130 | ~150 | ~95 | ~180 |
| Time to prototype | 3 hrs | 45 min | 1.5 hrs | 1 hr | 30 min | 2 hrs |
| Avg tokens/run | 2,847 | 4,216 | 2,912 | 2,791 | 3,340 | 3,102 |
| Multi-agent | Yes (graph) | Yes (teams) | Manual | Yes (handoffs) | Yes (hierarchy) | Yes (AgentTeam) |
| Type safety | TypedDict | Pydantic config | Full generics | Generic context | Minimal | Standard |
| MCP support | Yes | Limited | Native + A2A | Native | Yes | Yes |
| Model-agnostic | Yes | Yes | Yes (20+) | Yes (100+) | Yes (LiteLLM) | Gemini-first |
| Best debugger | LangSmith | Logs | IDE/types | Built-in tracing | Code output | ADK Web UI |
| GitHub stars | ~48K | ~44K | ~15K | ~16K | ~26K | ~23K |
| 2 AM debug | 9/10 | 5/10 | 8/10 | 7/10 | 8/10 | 6/10 |
Keine dieser Zahlen erzählt die ganze Geschichte, aber sie bilden einen ehrlicheren Ausgangspunkt als die meisten Vergleichsbeiträge.
Rechnen Sie damit, dass sich die Situation ändert
Diese Frameworks entwickeln sich schneller, als jemand sie dokumentieren kann. Während des Schreibens wurde LangGraph mit einem großen Update ausgeliefert. CrewAI’s Unternehmensversion erhielt innerhalb einer Woche neue Integrationen. PydanticAI fügte Unterstützung für das A2A-Protokoll hinzu, und Google ADK veröffentlichte bereits Tage zuvor eine SkillToolset-Funktion.
Jeder Vergleich hat eine Haltbarkeit. In sechs Monaten könnten sich die Leistungsunterschiede verringern, fehlende Funktionen hinzukommen, und das Framework, das Sie zuvor abgelehnt haben, könnte zur offensichtlichen Wahl werden. Wählen Sie daher das Framework, das Ihr Team um 2 Uhr morgens trotz laufender Störungen und wartender Kunden noch debuggen kann – und nicht das mit den meisten GitHub-Stars.
Weitere Literatur
- Agent Plugins 1.0.0: Das gemeinsame Paketformat für Fähigkeiten und MCP-Server — Agent Plugins 1.0.0 standardisiert Plugin-Verzeichnisse, plugin.json, Fähigkeiten sowie mcp.json bei den Clients. Was davon abgedeckt wird, was bei der Sicherheit weggelassen wird, sowie ein Beispiel für die Google Agents CLI.
- MCP, A2A und ACP in der Praxis: Wie eine Bank Tools und Agenten miteinander verbindet — Wie MCP, A2A und ACP die Aufgabe teilen, Modelle mit Tools sowie Agenten miteinander zu verbinden, am Beispiel eines Bankassistenten, der Betrug und Kredite bearbeitet.