Zum Hauptinhalt springen

Open-Source-Frameworks für KI-Agenten

Experte

Sobald du ein paar Agenten von Hand gebaut hast, taucht immer wieder dieselbe Verkabelung auf: eine Schleife, die das Modell aufruft, das angeforderte Tool ausführt, das Ergebnis zurückspeist und stoppt, wenn die Aufgabe erledigt ist. Agent-Frameworks verpacken diese Verkabelung — plus Zustand, Speicher und Multi-Agenten-Koordination — sodass du weniger Klebecode schreibst. Diese Seite ist eine langlebige, anbieterneutrale Übersicht der wichtigsten Open-Source-Optionen, was sie dir wirklich bieten und wie man auswählt. Fast alle sind modellunabhängig: Sie funktionieren mit Claude, GPT, Gemini und lokalen Open-Weight-Modellen.

What you'll learn
  • Wisse, was ein Agent-Framework dir gegenüber einer handgebauten Schleife bietet — und was nicht
  • Erkenne die drei Archetypen: zustandsbehaftete Graphen, rollenbasierte Crews und minimale Loops
  • Nutze ein wiederholbares Verfahren zur Auswahl — wobei du Komplexität gegen Kontrolle abwägst
  • Behalte im Kopf, dass diese meist modellunabhängig sind — das Framework bindet dich selten an einen Anbieter

Was ein Agent-Framework dir wirklich bietet​

Streift man das Branding ab, bietet dir ein Framework eine Teilmenge von vier Dingen:

  • Orchestrierung — die Steuerungsschleife. Sequentielle Schritte, Verzweigungen, Wiederholungen, Schleifen-bis-fertig und (zunehmend) dauerhafte Ausführung, die einen Absturz übersteht und dort weitermacht, wo sie aufgehört hat.
  • Tools — ein standardisierter Weg, eine Funktion zu deklarieren, die das Modell aufrufen kann, ihre Argumente zu validieren, sie auszuführen und das Ergebnis zurückzugeben. Dieselbe describe→call→execute→return-Schleife, die du bereits von der Tool-Nutzung kennst.
  • Speicher & Zustand — ein Ort, um den Gesprächsverlauf, Notizen und abgerufene Dokumente über mehrere Runden hinweg zu behalten, damit der Agent zwischen den Schritten nicht vergesslich ist.
  • Multi-Agent — Muster für mehrere spezialisierte Agenten, die einander Arbeit übergeben: ein Supervisor, der an Worker delegiert, oder Peers, die gemeinsam an einer Aufgabe arbeiten. (Konzeptionell dieselbe Idee wie die Subagenten von Claude Code.)

Ein Framework lohnt sich, wenn du andernfalls alle vier von Hand schreiben und pflegen müsstest. Es lohnt sich nicht, wenn deine Aufgabe lautet „rufe das Modell auf, führe ein oder zwei Tools aus, gib eine Antwort zurück" — dort ist das Framework Overhead, gegen den du Zeit verlierst.

Die drei Archetypen​

Frameworks unterscheiden sich weniger, als ihr Marketing suggeriert. Es gibt eigentlich drei Formen, und die meisten Projekte sind eine Variation einer davon:

  • Zustandsbehafteter Graph / Workflow. Du modellierst den Agenten als expliziten Graphen aus Knoten und Kanten (oder Schritten und Übergängen). Maximale Kontrolle, inspizierbarer Zustand, gut für langlaufende und Human-in-the-Loop-Abläufe. Mehr zu lernen am Anfang. → LangGraph, LlamaIndex Workflows.
  • Rollenbasierte Crew. Du beschreibst Agenten über ihre Rolle („Rechercheur", „Autor", „Prüfer") und lässt sie zusammenarbeiten oder einen Prozess durchlaufen. Schnell, um ein Multi-Agenten-Team auszudrücken; du tauschst etwas feingranulare Kontrolle gegen die High-Level-Abstraktion. → CrewAI und der konversationelle Multi-Agenten-Stil von AutoGen.
  • Minimaler Loop / wenige Abstraktionen. Eine dünne Schicht über dem nativen Tool-Calling des Modells, mit Übergaben zwischen ein paar Agenten und nicht viel mehr. Leicht von Anfang bis Ende zu lesen, leicht wieder fallenzulassen. → OpenAI Agents SDK (der produktionsreife Nachfolger des experimentellen Swarm) und die einfache Schleife, die du selbst schreibst.
Pro tip
  • Beginne mit dem Einfachsten, das funktioniert — oft schlägt eine einfache Tool-Calling-Schleife ein schwergewichtiges Framework.

Eine kurze Tour (Positionierung prüfen, bevor du dich festlegst)​

Dies sind die offenen Projekte, die man kennen sollte. Namentlich nur genannt, weil das echte Repo jedes einzelnen verifiziert wurde; alles Volatile steckt hinter der VerifyNote oben.

  • LangGraph — ein Low-Level-Orchestrierungs-Framework für zustandsbehaftete, langlaufende Agenten, modelliert als Graphen; dauerhafte Ausführung und Human-in-the-Loop sind erstklassig unterstützt. Eigenständig oder mit dem breiteren LangChain-Ökosystem nutzbar. Modellunabhängig.
  • LlamaIndex — begann als Daten-/RAG-Framework (Connectors, Indizes, Retrieval) und liefert nun auch eine ereignisgesteuerte Workflows-Schicht für Agenten. Stark, wenn dein Agent im Kern Retrieval über deine Dokumente ist.
  • Microsoft AutoGen — ein Framework für konversationelle Multi-Agenten-Systeme. Stand Mitte 2026 ist es im Wartungsmodus; Microsoft leitet neue Projekte zu einem einheitlichen Nachfolger (Microsoft Agent Framework, der AutoGen + Semantic Kernel zusammenführt). Prüfe den aktuellen Status, bevor du beginnst.
  • CrewAI — ein rollenbasiertes Framework: Definiere Agenten über Rolle und Ziel, organisiere sie in Crews (autonome Zusammenarbeit) oder Flows (ereignisgesteuerte Steuerung). Schneller Weg zu einem Multi-Agenten-Team.
  • OpenAI Agents SDK — ein bewusst leichtgewichtiges Framework mit wenigen Abstraktionen für Multi-Agenten-Workflows mit Übergaben. Trotz des Namens ist es anbieterunabhängig (seine Docs nennen Unterstützung für über 100 LLMs) und es ist der produktionsreife Nachfolger des experimentellen Swarm.
  • Die einfache Agenten-Schleife — gar kein Framework: deine eigene while-Schleife um das native Tool-Calling des Modells. Der richtige Standard für einfache Agenten und das, was jedes Framework oben letztlich umhüllt.

Wie man ein Framework auswählt​

Guided walkthrough1 of 6
  1. Ein Satz dazu, was der Agent tut, plus die nicht verhandelbaren Punkte: Latenz, Kostenobergrenze, Datenschutz, ob Läufe einen Absturz überstehen müssen und ob ein Mensch Schritte freigeben muss.

Das, was jedes Framework umhüllt​

Bevor du nach irgendeiner Bibliothek greifst, hilft es, die Schleife zu sehen, auf der sie alle aufbauen. Das ist die ganze Idee — das Modell entscheidet, du führst aus, wiederholst, bis es fertig ist:

# Provider-neutral agent loop — the core every framework wraps.
# `model_call` and `run_tool` are yours; swap in Claude, GPT, Gemini, or a local model.

def agent_loop(task, tools, max_steps=10):
    messages = [{"role": "user", "content": task}]

    for _ in range(max_steps):
        # 1. Ask the model what to do next (it sees the tool schemas).
        response = model_call(messages, tools=tools)

        # 2. No tool requested → the model is done. Return its answer.
        if not response.tool_calls:
            return response.text

        # 3. Run each requested tool and feed results back in.
        messages.append(response.as_message())
        for call in response.tool_calls:
            result = run_tool(call.name, call.arguments)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": result,
            })

    return "Stopped: hit max_steps without finishing."

Wenn du das lesen kannst, verstehst du, was jedes Framework auf dieser Seite unter der Haube tut. Graphen fügen expliziten Zustand und Verzweigungen hinzu; Crews fügen Rollen und Delegation hinzu; minimale SDKs fügen saubere Übergaben hinzu — aber der Herzschlag ist immer diese Schleife.

Minimaler Agenten-System-Prompt (passt zur Schleife oben)

You are a task-completing agent with access to tools.

Loop:
1. Think briefly about the next single step toward the goal.
2. If a tool would help, call exactly ONE tool with valid arguments.
3. When you have enough to answer, stop calling tools and give the final answer.

Rules:
- Prefer the fewest tool calls that get the job done.
- If a tool fails, read the error and adjust — do not repeat the same call.
- Never invent tool results; use only what tools actually returned.
- If the goal is impossible with the available tools, say so and stop.

Goal: {one-sentence task}

Eine Anmerkung zum Hype​

Kein Framework hier ist „das Beste" — diese Frage ist falsch gestellt. Die Graph-Frameworks gewinnen bei Kontrolle und Beständigkeit; die Crew-Frameworks gewinnen darin, ein Team schnell auszudrücken; die minimalen gewinnen bei Lesbarkeit und geringer Bindung; und eine einfache Schleife gewinnt öfter, als Framework-READMEs zugeben. Die richtige Wahl ist das kleinste Werkzeug, das deinen schwierigsten Schritt klar macht. Wie bei der Wahl eines Modells lass deine eigene Aufgabe entscheiden — nicht eine Star-Zahl. Dieselbe Disziplin, die du bei Evals anwenden würdest, gilt auch hier: prototypisieren, an echten Fällen messen, einen Ausweg offenhalten.

Teste dich selbst

0/3
  1. Dein Agent macht einen Modellaufruf, führt ein einzelnes Such-Tool aus und gibt eine Antwort zurück. Was ist der richtige Startpunkt?
  2. Du brauchst einen Agenten, der lange läuft, einen Absturz überstehen und wieder aufnehmen muss und einem Menschen erlaubt, bestimmte Schritte freizugeben. Welcher Archetyp passt am besten?
  3. Ein Teamkollege sagt: ‚Das OpenAI Agents SDK bedeutet, dass wir an GPT gebunden sind.' Stimmt das?
Agent-Frameworks — Kernideen
Drücke Enter oder die Leertaste, um die Karte umzudrehen. Nutze die Pfeiltasten links und rechts, um zwischen den Karten zu wechseln.Begriff angezeigt.
1 / 6
Key takeaways
  • Ein Agent-Framework verpackt Orchestrierung, Tools, Speicher und Multi-Agenten-Koordination — übernimm eines nur, wenn du andernfalls alle vier selbst bauen würdest.
  • Drei Archetypen decken das Feld ab: zustandsbehaftete Graphen (Kontrolle/Beständigkeit), rollenbasierte Crews (schnelle Teams) und minimale Loops (Lesbarkeit, geringe Bindung).
  • Fast alle davon sind modellunabhängig — sie laufen auf Claude, GPT, Gemini und lokalen Modellen; verifiziere pro Projekt, statt es anzunehmen.
  • Kein Framework ist universell ‚das Beste'; wähle das kleinste Werkzeug, das DEINEN schwierigsten Schritt klar macht, und halte einen Ausweg offen.
  • Die einfache Tool-Calling-Schleife ist der ehrliche Standard — und sie ist genau das, was jedes Framework umhüllt.
  • Der Wartungsstatus ändert sich (z. B. AutoGen → ein Nachfolger); bestätige, dass ein Projekt aktiv gepflegt wird, an seinem eigenen Repo, bevor du dich festlegst.

Quellen & weiterführende Literatur​

Weiter​

  • Der anbieterneutrale Weg, ein Modell auszuwählen → Ein Modell auswählen
  • Die Schleife, die diese Frameworks umhüllen → Tool-Nutzung
  • Multi-Agent auf die Claude-Code-Art → Subagenten
  • Wie man Kandidaten tatsächlich vergleicht → Evals