10 KI-Agenten-Frameworks, die man im Jahr 2026 kennen sollte: LangGraph, CrewAI und weitere.

Die Agent-Frameworks vermehrten sich schnell. OpenAI veröffentlichte ein Agents SDK, Google brachte ADK heraus, Hugging Face stellte Smolagents vor und das Pydantic-Team entwickelte eine typisierte Agent-Schicht – all das neben den älteren Lösungen. Die Auswahl zwischen ihnen wird einfacher, sobald man erkennt, dass jede davon auf einer einzigen Idee setzt: wie Agenten miteinander koordinieren.

Die Übersicht: acht Koordinationssysteme

• graphbasiert: Agenten sind Knoten, Übergänge sind Kanten. LangGraph nutzt dieses Prinzip.
• rollenbasiert: Agenten fungieren wie Jobtitel in einem Team. CrewAI.
• konversationell: Agenten befinden sich in einer Gruppenchat-Session und wechseln sich ab. AutoGen und AG2.
• hierarchisch: Ein übergeordneter Agent weist Aufgaben an untergeordnete Agenten zu, ähnlich wie in einer Organisationsstruktur. Google ADK.
• kodenerfüllend: Die Aktion des Agenten besteht darin, Python-Code zu schreiben und auszuführen. Smolagents.
• übertragungsbasiert: Ein Agent gibt den Kontrollverlust bewusst an einen anderen weiter. OpenAI Agents SDK.

Typsichere Schleife: Validierung mit Pydantic in jedem Schritt. PydanticAI.

Protokollbasiert: Agenten kommunizieren über A2A und MCP als grundlegende Voraussetzung. OpenAgents.

Semantic Kernel und das Claude Agent SDK passen nicht perfekt in diese Liste und erhalten daher eigene Abschnitte weiter unten. Angesichts dieser Liste reduziert sich die Auswahl des Frameworks auf eine Frage: Welches Koordinationsmodell eignet sich für Ihr Problem?

1. LangGraph, der Standard in der Produktion

LangGraph überholte CrewAI Anfang 2026 in Bezug auf die GitHub-Stars, unterstützt durch die Adoption in Unternehmen. Seine Graphstruktur eignet sich für Produktionsanforderungen wie Audit-Trail und Rollback-Punkte.

Man definiert ein gerichtetes Graphenmodell explizit. Agenten, Tools und Kontrollpunkte sind Knoten, während bedingte Kanten bestimmen, was als Nächstes ausgeführt wird. Das Framework speichert den Zustand zwischen den Schritten und verwendet Reducer-Logik, um gleichzeitig eingehende Aktualisierungen zu kombinieren. Dadurch eignet es sich hervorragend für Fälle, in denen eine präzise Kontrolle über die Ausführungsreihenfolge, das Verzweigen sowie die Fehlerbehebung erforderlich ist. Es erreichte Version 1.0 Ende 2025, wurde zur Standard-Laufzeitumgebung für LangChain’s Agenten und unterstützt sowohl Python als auch JavaScript.

Persistenz wird durch Kontrollpunkte mit Zeitreisefunktion integriert: Jeder frühere Zustand kann wiedergegeben werden, was für das Debuggen sowie die Einhaltung von Vorgaben wichtig ist. In Kombination mit LangSmith erhält man einige der besten Trace-Funktionen in dieser Kategorie.

Der Preis ist die notwendige Boilerplate-Struktur. Ein einfacher ReAct-Agent umfasst in Smolagents etwa 40 Zeilen und in LangGraph rund 120 Zeilen. Man tauscht Ausführlichkeit gegen mehr Kontrolle ein.

Es eignet sich für Produktionsysteme, die eine explizite Zustandsdarstellung und Nachvollziehbarkeit benötigen, für Workflows mit Schleifen, Verzweigungen und bedingtem Routing, für Agenten, die Kontrollpunkte zur menschlichen Freigabe benötigen, sowie für Teams, die bereits in LangChain investiert haben.

Ein minimales Beispiel definiert einen typisierten Zustand, eine Funktion, die entscheidet, ob nach zehn Iterationen weitergemacht werden soll, einen Agentenknoten und einen Tools-Knoten sowie Kanten, die zwischen ihnen schließen, bis die Grenze erreicht ist.

from langgraph.graph import StateGraph, END
from typing import TypedDict


class AgentState(TypedDict):
    messages: list
    iteration_count: int

def should_continue(state: AgentState) -> str:
    if state["iteration_count"] >= 10:
        return "end"
    return "continue"

graph = StateGraph(AgentState)

graph.add_node("agent", run_agent)
graph.add_node("tools", run_tools)
graph.add_conditional_edges("agent", should_continue, {"continue": "tools", "end": END})
graph.add_edge("tools", "agent")

2. CrewAI – Schneller Einstieg

Durch das rollenbasierte Design von CrewAI kann ein kleines Team innerhalb von etwa einer halben Stunde ein funktionsfähiges Mehr-Agenten-System aufbauen.

Man beschreibt jeden Agenten anhand seiner Rolle, seines Hintergrunds und seines Ziels, gruppiert sie anschließend zu einer Crew mit Aufgaben und lässt das Framework die Koordination übernehmen. Der Code liest sich fast wie gewöhnliches Englisch. Man deklariert einen Forscher, einen Schreiber und einen Reviewer, weist ihnen Aufgaben zu – CrewAI entscheidet dann, wer was und wann erledigt. Es wird keine Graphentheorie verwendet.

Die Kosten zeigen sich an zwei Stellen. Im Jahr 2026 veröffentlichte Vergleiche deuten auf eine mäßige Token-Kostenbelastung hin – etwa 18 Prozent mehr im Vergleich zu einer äquivalenten LangGraph-Lösung für eine Crew zur Bearbeitung von Tickets mit drei Agenten – wobei solche Zahlen vom Arbeitsaufwand abhängen. Wenn außerdem ein Pipeline mit fünf Agenten fehlschlägt, kann die Abstraktion undurchsichtig werden und das Debuggen erschweren. Der Zustand besteht einfach aus den Aufgabenergebnissen, die von einem Agenten an den nächsten weitergegeben werden.

Es eignet sich für schnelle Prototypen und MVPs, für die Geschäftsautomatisierung, die auf menschlichen Teamrollen basiert, für Teams ohne spezialisierte AI-Entwickler sowie für kleine Organisationen, die den ersten Schritt in Richtung Agentenautomatisierung wagen. Eine gängige Vorgehensweise: Teams entwickeln zunächst in CrewAI Prototypen und wechseln anschließend zu LangGraph, sobald sie eine ordnungsgemäße Zustandsverwaltung sowie bedingte Routing-Funktionen benötigen.

from crewai import Agent, Task, Crew


researcher = Agent(role="Research Analyst", goal="Find key facts", backstory="Expert researcher")

writer = Agent(role="Content Writer", goal="Write clear summaries", backstory="Skilled communicator")

research_task = Task(description="Research AI agent frameworks", agent=researcher)

writing_task = Task(description="Write a summary of findings", agent=writer)

crew = Crew(agents=[researcher, writer], tasks=[research_task, writing_task])

result = crew.kickoff()

3. AutoGen und AG2 – Agenten im Dialog

In AutoGen sind Workflows Gespräche. Agenten schließen sich einer Gruppenchat-Gruppe an, sprechen in mehreren Schritten miteinander und ein Selektor wählt den nächsten Sprecher aus. Während LangGraph ein Netzwerk aus Knoten und Kanten darstellt, moderiert AutoGen eine Diskussion.

Die erste Version, 0.2, machte Agenten populär, die durch Dialoge Antworten diskutieren und verfeinern. Die Überarbeitung 0.4, die als AG2 weiterentwickelt wurde, wechselte zu einem ereignisgesteuerten Kern mit asynchroner Ausführung und plattformunabhängigen Orchestrierungsstrategien.

Das Problem ist der Aufwand. Jeder Schritt erfordert einen vollständigen Aufruf des LLM mit dem gesamten bisherigen Gesprächsinhalt, sodass vier Agenten, die fünf Runden lang diskutieren, mindestens zwanzig Aufrufe benötigen. Das ist für hochvoluminöse, Echtzeit-Aufgaben wie den Kundenservice zu aufwendig. Es lohnt sich hingegen bei offline durchgeführten Aufgaben, bei denen Qualität wichtiger ist als Geschwindigkeit. Der Zustand der Agenten wird standardmäßig im Gesprächsverlauf in Erinnerung gespeichert.

Gute Anwendungsbereiche sind Forschung und Analyse, bei denen Agenten diskutieren und ihre Ansätze verfeinern, sowie Codegenerierung, bei der ein Agent den anderen kritisiert. Ebenso geeignet ist alles, was von echter Abstimmung profitiert, sowie Teams, die zudem .NET-Unterstützung benötigen, da AutoGen sprachübergreifende Schnittstellen bietet. AutoGen Studio fügt eine no-code-Benutzeroberfläche hinzu, um mehragentige Konfigurationen auszuprobieren – praktisch für Personen ohne Ingenieurshintergrund.

4. Google ADK, der Delegierungsbaum

ADK, das im April 2025 veröffentlicht wurde, ordnet Agenten in einen Baumstruktur an. Ein Wurzelagent erhält eine Aufgabe und weist Unteraufgaben an seine „Kinder“-Agenten weiter, die wiederum eigene Kinder haben können. Man denke an eine Organisationsstruktur und nicht an eine Gruppenchat-Struktur.

Es ist eng mit Vertex AI, Gemini und Google Cloud verbunden, obwohl auch andere Modelle funktionieren. Seine herausragende Eigenschaft ist die native Unterstützung für A2A, das Agent-zu-Agent-Protokoll, sodass ein ADK-Agent einen in LangGraph oder CrewAI geschriebenen Agenten über die Standardaufgabenschnittstelle von A2A finden und aufrufen kann. Der Sitzungszustand wird mit einsetzbaren Backends verarbeitet.

Es ist die natürliche Wahl für Teams, die tief in Google Cloud arbeiten, für Systeme, die Agenten über verschiedene Frameworks koordinieren müssen, für Unternehmen, die auf Googles Konformitätszertifizierungen angewiesen sind, sowie für Workflows mit einer klaren Delegationskette.

5. OpenAI Agents SDK – klein und schnell

Im März 2025 wurde das Agents SDK eingeführt, das das experimentelle Swarm-Projekt durch eine produktreife Lösung ersetzte. Die Kernidee besteht im Übergabeprozess: Ein Agent beendet seine Aufgabe und überträgt explizit die Kontrolle sowie den Gesprächskontext an einen anderen Agenten. Jeder Agent wird durch Anweisungen, ein Modell, Tools sowie die Liste der Agenten definiert, an die er den Kontext weitergeben kann. Das Ergebnis ist vorhersehbar und leicht verständlich.

Die Einschränkungen sind real. Es ist an OpenAI-Modelle gebunden, es gibt keine Möglichkeit, eigene Modelle zu verwenden. Für lang andauernde Aufgaben fehlt eine integrierte Checkpoint-Funktion, die Kontrolle über die Kommunikation zwischen Agenten ist begrenzt und das Fehlerrhandling ungenau. Der Zustand besteht aus Kontextvariablen, die standardmäßig vorübergehend sind. Dank einer einfach strukturierten API ist die Lernkurve gering.

Wählen Sie dies, wenn Sie bereits mit OpenAI-Modellen arbeiten, Ihr Ablauf aus einer einfachen Abfolge von Übertragungen besteht ohne starke Anforderungen an den Zustand, oder wenn Sie vor einer Investition in etwas Größeres ein Prototyp erstellen möchten.

from agents import Agent, handoff


support_agent = Agent(name="Support", instructions="Handle general questions")

billing_agent = Agent(name="Billing", instructions="Handle payment issues")

support_agent.tools = [handoff(billing_agent, "Transfer billing questions")]

6. Smolagents – Code als Handlung

Hugging Faces Bibliothek verfolgt einen vereinfachten Ansatz. Anstelle ausgefeilter Anweisungen und Orchestrierung wird ein minimales Schleifenverfahren verwendet, bei dem der Agent Code schreibt und ausführt, um sein Ziel zu erreichen.

Die meisten Agenten wählen ein Tool sowie Argumente in Form von JSON aus. Smolagents’ CodeAgent schreibt direkt in Python, sodass jede Bibliothek als Tool verfügbar wird, sobald die Importierung autorisiert wurde. Zudem wird die Unterstützung für lokale Modelle ermöglicht, die von Hugging Face für sein eigenes Ökosystem entwickelt wurden. Aus Sicherheitsgründen kann die Ausführung über Blaxel, E2B, Modal, Docker oder einen Pyodide-plus-Deno WebAssembly-Sandbox abgesichert werden.

Die Schwäche liegt in der Abhängigkeit von der Qualität des Modells. Modelle der Klasse GPT-4o oder Claude Sonnet erzeugen zuverlässigen Code, während Modelle mit etwa 7 Milliarden Parametern konstant Fehler aufweisen. Diese Abhängigkeit ist größer als in anderen Frameworks.

Es eignet sich für Forschungs- und Code-Ausführungs-Agenten, Datenanalyse-Pipelines, die von generiertem Code profitieren, Nutzer des Hugging Face Hub sowie Prototypen mit lokalen Open-Source-Modellen.

from smolagents import CodeAgent, InferenceClientModel, DuckDuckGoSearchTool

model = InferenceClientModel()

agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=model)

result = agent.run("Find the top 5 AI frameworks by GitHub stars and plot a bar chart")
# The agent writes and executes Python to search, process data, and generate the chart

7. PydanticAI, typisierte Verträge

Pydantic AI übernimmt die Typsicherheit und das Entwicklererlebnis von Pydantic auf Agentenarbeit und bietet dabei ein Gefühl, das dem von FastAPI ähnelt. Sie deklarieren Eingaben, Tool-Signaturen sowie Ausgaben als Python-Typen, wobei das Framework diese validiert und OpenTelemetry-Instrumentierung hinzufügt.

Sein Loop verwendet bei jedem Schritt die Abhängigkeitsinjektion: Sie geben an, was eingeht und was herauskommt, wobei Pydantic den Vertrag durchsetzt. Wenn Ihr Pipeline zuverlässige, validierte Ausgabeformate benötigt, bietet dies Pydantic-ähnliche Garantien dafür, was das Modell zurückgibt. Jeder, der bereits Pydantic oder FastAPI verwendet hat, wird es wiedererkennen.

Es eignet sich für Anwendungen mit schema-gestützt validierten Ausgaben, wie in der Finanzbranche, im Gesundheitswesen und bei rechtlichen Tätigkeiten, für Teams, die Wert auf Typsicherheit und Testbarkeit legen, für Python-Entwickler, die explizite Verträge für jede Interaktion wünschen, sowie insbesondere als Schicht zur Strukturierung der Ausgaben innerhalb größerer Orchestrierungsplattformen wie LangGraph.

8. Microsoft Semantic Kernel – der Unternehmensweg

Semantic Kernel basiert auf Plugins, wobei Agenten als orchestrierte Planer fungieren, und ist so konzipiert, dass er wie herkömmliche Unternehmenssoftware wirkt und nicht wie ein Forschungsprototyp. Er ist leichter als einige Konkurrenten, integriert sich aber stark mit .NET.

Es ist die Wahl für Teams auf Azure, die C# oder Java programmieren und innerhalb von Microsofts Konformitätsökosystem deployen. Es ist hauptsächlich für Azure OpenAI optimiert, unterstützt aber auch andere Anbieter. Es eignet sich für Enterprise-.NET-, C#- und Java-Teams, Azure-first-Deployment-Szenarien, Organisationen, die bereits Copilot Studio nutzen, sowie Workflows, die mit Microsoft 365 und Office verbunden werden müssen.

9. Claude Agent SDK – Zuverlässigkeit an erster Stelle

Anthropics SDK fungiert als Werkzeugkette mit Subagenten. Claude entscheidet, welche Tools verwendet werden sollen, verknüpft sie miteinander und kann über die Agent-Infrastruktur von Claude Code isolierte Subagenten für parallele Arbeit starten.

Es legt Wert auf zuverlässige Fehlerbehandlung und sicheres Verhalten statt auf reine Geschwindigkeit, integriert sich nahtlos mit MCP für Tool-Verbindungen und kann Claudes erweiterte Denkfähigkeiten für komplexe Schlussfolgerungen nutzen. Es läuft ausschließlich auf Claude-Modellen. Externer Zustand wird über MCP-Server übertragen, während der In-Session-Zustand im Kontext von Claude gespeichert wird.

Berücksichtigen Sie es, wenn Sie bereits auf der Plattform von Anthropic sind, wenn Sicherheitsgarantien und Einhaltung der Inhaltsrichtlinien wichtig sind, für Arbeiten mit langen Kontexten, die von einem 200-K-Token-Fenster profitieren, sowie für Projekte, die in das umfassendere MCP-Tool-Ecosystem eingebunden sind.

10. OpenAgents, ein auf Protokollen basierendes Netzwerk

OpenAgents erstellt dauerhafte Agentennetze, in denen die Mitglieder über offene Standards kommunizieren – MCP für Tools sowie A2A zwischen den Agenten. Ein LangGraph-Agent, ein CrewAI-Agent und ein selbst entwickelter Python-Agent können sich demselben Netzwerk anschließen. Es geht um Interoperabilität zwischen Frameworks und Organisationen statt um einen einheitlichen, vorgegebenen Workflow.

Es ist jünger und verfügt über eine kleinere Community als AutoGen oder LangGraph sowie über weniger fertige Integrationen als das LangChain-Ecosystem. Es eignet sich für langfristig bestehende Agentenökosysteme, die sich weiterentwickeln, für die Zusammenarbeit zwischen Organisationen über A2A, für Teams, die Agenten aus verschiedenen Frameworks benötigen, um miteinander in Kontakt zu treten, sowie für Infrastrukturprojekte, bei denen die Unterstützung offener Protokolle unverzichtbar ist.

Die Wahl treffen

Beginnen Sie damit, wer die Entwicklung vorantreibt.

• Ein Einzelentwickler an seinem ersten Agentenprojekt: CrewAI oder das OpenAI SDK.

Ein Python-Team, das Typsicherheit schätzt: PydanticAI.

Ein Forschungsteam, das sich auf Codeausführung konzentriert, oder ein Data Scientist in der Hugging Face-Welt: Smolagents.

Ein Unternehmens- .NET- oder Azure-Team: Semantic Kernel.

Dann zu dem, was gerade entwickelt wird.

• Ein Produktionsystem, das Zustandsverwaltung und Nachvollziehbarkeit benötigt: LangGraph.
• Ein Geschäftsworkflow mit klarer Rollentrennung: CrewAI.
• Ein Diskussions- oder Code-Review-Pipeline zwischen Agenten: AutoGen oder AG2.
• Eine Google Cloud-Implementierung mit Gemini: ADK.
• Etwas, das in den Frameworks verschiedener Anbieter funktionieren muss: OpenAgents.
• Eine sicherheitskritische Anwendung: das Claude Agent SDK.

Dann zu dem, was unter keinen Umständen kompromittiert werden darf.

• Modellunabhängig für OpenAI-, Anthropic- und lokale Modelle: LangGraph, CrewAI, AutoGen oder Smolagents.
• Nur OpenAI, schnellste Einrichtung: das OpenAI Agents SDK.
• Für Gemini optimiert: ADK.
• Nur Claude, mit der stärksten Sicherheitsausrichtung: Anthropics SDK.
• Überprüfte, typsichere Ausgaben: PydanticAI.
• Interoperabilität zwischen verschiedenen Frameworks: OpenAgents.

Als grobe Einschätzung des Marktes scheint LangGraph die Produktions- und Unternehmensumgebung dominieren zu wollen, Smolagents wird voraussichtlich in der Hugging Face-Community sowie in der Forschung vorherrschen, während CrewAI und AutoGen um den zugänglichen Mittelbereich konkurrieren werden.

Das eigentliche Kriterium

Wählen Sie das Framework, das zu Ihrem Problem, Ihrem Team sowie dem Stack passt, den Sie bereits haben. Nicht das mit den meisten Bewertungen oder das neueste. Wählen Sie das, das Ihr spezifisches Koordinationsproblem einfach ausdrücken und leicht debuggen lässt. Das war schon immer die Hauptaufgabe.