LangGraph vs AutoGen: Zustandsverfolgung im Vergleich – Checkpoint-Mechanismus, Timeout-Wiederherstellung und Auswahlentscheidung

30 Schritte – ein Agent zur Literaturrecherche, insgesamt 2 Stunden 40 Minuten Laufzeit.

Bei Schritt 25: Timeout an der Datenbankschnittstelle, Absturz.

Die ersten 24 Schritte umsonst. API-Kosten, Wartezeit, bereits erstellte Literaturzusammenfassungen – alles weg.

Kein Einzelfall. Mit AutoGen habe ich komplexe Workflows gebaut – Zustand unkontrollierbar, Agenten liefen unkontrolliert, Fehlersuche kostete das Dreifache der Entwicklungszeit. Später mit LangGraph: schon der einfache Prototyp erforderte über hundert Zeilen Zustandsdefinition. Beide Frameworks – beide mit Fallstricken.

LangGraph vs AutoGen bei der Zustandsverwaltung: grundverschiedene Designphilosophien. Eines nutzt explizite Zustandsmaschinen zur Ablaufsteuerung, das andere lässt Agenten per Dialogprotokoll frei verhandeln. Falsches Framework gewählt? 80 % der gescheiterten Agent-Projekte scheitern nicht am LLM – sondern am falschen Weg der Zustandsverfolgung von Anfang an.

Dieser Artikel vergleicht beide Frameworks in 12 Dimensionen – Checkpoint-Mechanismus, Timeout-Wiederherstellung, verteilte Unterstützung – mit echten Fallstricken, Auswahlentscheidungsbaum und lauffähigem Code. Danach sollten Sie schnell einschätzen können: Welches Framework passt zu Ihrem Projekt?

Zustandsverwaltung als Lebenslinie: Warum Checkpoint die Lebensader eines Agent ist

Für einen Kunden habe ich einen Agent zur Literaturrecherche gebaut: 10 aufeinanderfolgende Aufrufe akademischer Datenbank-APIs, 200 Literaturzusammenfassungen, abschließender Übersichtsbericht.

Geschätzte Laufzeit: 3 Stunden. Bei Schritt 25 von 30: Timeout an der Datenbankschnittstelle, Absturz.

Klassischer zustandsloser Agent – die ersten 24 Schritte umsonst. Erstellte Zusammenfassungen, API-Kosten, 2 Stunden 40 Minuten Wartezeit – alles verloren. Neustart von vorn, API-Kosten erneut.

Kundenfrage: Können wir bei Schritt 25 weitermachen?

Antwort: Nein. Der Zustand klassischer Agenten existiert nur im Speicher – Prozessabbruch, Zustand weg.

Fünf Katastrophen zustandsloser Agenten

Den Fehler kenne ich. Mit AutoGen für komplexe Kundenservice-Ticket-Workflows: Zustand unkontrollierbar, Agenten liefen unkontrolliert, Fehlersuche kostete das Dreifache. Später mit LangGraph Zustandsgraph – schon der Prototyp über hundert Zeilen Code.

Zusammengefasst: Zustandslose Agenten haben fünf kritische Probleme:

1. Nach Neustart geht der gesamte Dialogverlauf verloren

Neue Version deployen, Serverwartung, unerwarteter Absturz – jeder Prozessabbruch löscht den Zustand. Laufende Nutzerdialoge brechen sofort ab.

2. Mehrschritt-Tasks lassen sich nach Unterbrechung nicht fortsetzen

Lange Tasks (Literaturrecherche, Datenverarbeitungspipelines) – bei Fehler nur Neustart von vorn. 30 Schritte, Absturz bei Schritt 25: die ersten 24 umsonst.

3. Keine echte Multi-User-Parallelität, Zustände interferieren

Eine Agent-Instanz für mehrere Nutzer – Zustände vermischen sich. Nutzer A wird von Nutzer B überschrieben, Datenverunreinigung.

4. Keine Auditierung und Wiedergabe historischer Ausführungen

Produktionsproblem – wie hat der Agent entschieden? Keine Aufzeichnung. Bug reproduzieren? Kein historischer Zustand.

5. Lange Tasks bei Fehler komplett von vorn

Stundenlange Tasks (Datenverarbeitung, Batch-Generierung) – hohe Fehlerkosten. API-Gebühren, Zeit, Nutzererfahrung – alles verloren.

LangGraph vs AutoGen: Checkpoint-Reife im Vergleich

Die Checkpoint-Fähigkeiten unterscheiden sich deutlich.

Dimension	LangGraph	AutoGen
Native Checkpoint-Unterstützung	Jeder Knoten speichert automatisch einen Schnappschuss	Roadmap in Entwicklung
Produktionsreife	⭐⭐⭐⭐⭐ (De-facto-Standard 2026)	⭐⭐⭐ (noch in Entwicklung)
API-Stabilität	LangChain-Ökosystem stabil	v0.2 bis v0.5 große Migration, Projekte mussten neu schreiben

LangGraph hat Checkpoint von Anfang an eingebaut. Nach jedem Knoten: automatischer State-Schnappschuss. Nach Absturz Wiederaufnahme am Unterbrechungspunkt, ohne Wiederholung abgeschlossener Knoten.

AutoGen Zustandsverwaltung noch in Entwicklung. April 2024 veröffentlichte Microsoft die Persistence-Roadmap, März 2025 kam Save/Load (AgentChat.NET). Projekte mit AutoGen v0.2 – Upgrade auf v0.5, alle APIs ungültig, Code neu schreiben.

Checkpoint ist kein Nice-to-have – es ist die Lebensader des Agent. Produktion ohne Zustandspersistenz ist wie ohne Sicherheitsnetz.

LangGraph Checkpoint-Mechanismus im Detail

Checkpoint-Wesen: Nicht „Nachrichten speichern“, sondern „vollständigen Graph-Zustand speichern“

Viele verstehen Checkpoint falsch – als „Dialogverlauf speichern“.

Das stimmt nicht.

Ein Checkpoint speichert einen vollständigen Zustandsschnappschuss des Graphs in einem Ausführungsschritt. Enthalten:

• Aktuelle Werte aller Channels (jedes State-Feld)
• Aktuell ausgeführter Knoten
• Parent-Checkpoint-ID (Versionskette)
• Zeitstempel und Metadaten

Analog zu Git-Commit-Historie: Jede Knotenausführung erzeugt einen „Commit“, checkout zu jedem historischen Knoten möglich. Kein Dialog-Backup, sondern Workflow-Zustandsschnappschuss.

Checkpoint v4 Datenstruktur im Detail

LangGraph nutzt Checkpoint v4 mit 7 Kernfeldern laut LangChain-Dokumentation:

class Checkpoint:
    v: int                  # Versionsnummer (aktuell 4)
    ts: str                  # Zeitstempel ISO-Format
    id: str                  # UUID, eindeutige Schnappschuss-ID
    channel_values: dict     # Aktuelle Werte jedes State-Felds
    channel_versions: dict   # Versionsnummer pro Feld, Konflikterkennung
    versions_seen: dict      # Von Knoten gesehene Versionen, keine Doppelverarbeitung
    pending_sends: list      # Warteschlange ausstehender Nachrichten

channel_versions ist kein überflüssiges Feld.

LangGraph prüft damit, ob ein Knoten neu ausgeführt werden muss. Grundlage für Fortsetzung: Beim Wiederherstellen Channel-Versionen prüfen, bereits ausgeführte Knoten überspringen.

thread_id: „Paralleluniversum-Koordinaten“ für Multi-Session-Isolation

Eine Graph-Instanz kann unzählige Dialog-Threads bedienen.

Jeder Thread hat eine eigene Checkpoint-Sequenz, ohne gegenseitige Beeinflussung. Unterscheidung über thread_id.

Analog zu Spielstand-Slots: Jede thread_id ist eine eigene Speicherdatei. Nutzer A beeinflusst Nutzer B nicht.

config = {"configurable": {"thread_id": "user-001"}}
result = graph.invoke(input, config)

Andere thread_id – anderes Paralleluniversum.

Super-Step-Ausführungsablauf

LangGraphs Ausführung heißt Super-Step. Laut LangChain-Dokumentation:

[Vorherigen Checkpoint lesen]
  ↓
[Aktuellen Knoten ausführen, State aktualisieren]
  ↓
[Neuen Checkpoint schreiben (Schnappschuss)]
  ↓
[Nächsten Schritt entscheiden: weiter/warten/beenden]

Nach jedem Knoten automatischer Checkpoint. Nach Absturz Fortsetzung am Unterbrechungspunkt.

Drei Checkpoint-Speicher-Backends im Vergleich

Speichertyp	Einsatz	Eigenschaften
MemorySaver	Entwicklung/Debug	Im Speicher, nach Neustart verloren
SqliteSaver	Einzelserver-Produktion	SQLite-Persistenz, leichtgewichtig
PostgresSaver	Verteilte Produktion	PostgreSQL, pause/resume, verteilt

Entwicklung: MemorySaver. Produktion: PostgresSaver für verteiltes Deployment.

RedisSaver für hohe Parallelität, schnelle Lese-/Schreibvorgänge.

Fortsetzung nach Unterbrechung in der Praxis

Zurück zum Fall: 30 Schritte Literaturrecherche, Timeout bei Schritt 25.

Mit LangGraph Checkpointer vom Unterbrechungspunkt fortsetzen:

# Nach Fehler in Schritt 7 wiederherstellen
config = {"configurable": {"thread_id": "research-001"}}
recovered_state = compiled_graph.invoke({"step": 7}, config)
# Überspringt automatisch Schritte 1–6, setzt bei Schritt 7 fort

Gleiche thread_id, lädt neuesten Checkpoint, setzt fort.

Schritte 1–24 werden nicht wiederholt. API-Kosten und generierte Inhalte bleiben erhalten.

AutoGen Zustandsverfolgung: Der Preis der Roadmap-Entwicklung

Roadmap-Entwicklung der Zustandsverwaltung

AutoGens Zustandsverwaltung ist noch in Entwicklung.

Laut GitHub Issue #2358 veröffentlichte Microsoft im April 2024 die Persistence-and-State-Management-Roadmap. AutoGen v0.2 bis v0.5 – große API-Verschiebung, Projekte mussten neu schreiben.

Den Fehler kenne ich. Projekt mit AutoGen v0.2 – Upgrade auf v0.5, alle APIs ungültig. ConversableAgent, GroupChat – Schnittstellen geändert. Code neu schreiben.

März 2025: Save/Load for AgentChat.NET PR (#5841). AgentChat-Agents und Teams können auf Snapshots zurückrollen (Issue #4100). SingleThreadedAgentRuntime State Serialization dokumentiert (Issue #4108).

Zustandsverwaltung vorhanden, aber weniger ausgereift als LangGraph.

Abbruchbedingungen: Vier Schutzmechanismen

AutoGen-Schmerzpunkt: Zwei Agenten debattieren 50 Runden über „einfache oder doppelte Anführungszeichen“, verbrennen 5 $ API-Kosten.

Oder Nacht-Automatisierung läuft 8 Stunden wegen nicht beendetem Dialog – am nächsten Tag explodierte Rechnung.

AutoGen v0.4: ereignisgesteuerte Architektur, dauerhafte Nachrichtenschleife. Ohne Abbruchbedingungen entsteht ein Ressourcen-Schwarzes Loch.

Laut AutoGen-Dokumentation vier Abbruchtypen:

Abbruchtyp	Steuerdimension	Einsatz
MaxMessageTermination	Rundenkontrolle	Max. 10 Nachrichten
TextMentionTermination	Inhaltskontrolle	Schlüsselwort „TERMINATE“
TimeoutTermination	Zeitkontrolle	Verhindert langes Hängen
TokenUsageTermination	Kostenkontrolle	Verhindert Budgetüberschreitung

Kombiniert:

from autogen_agentchat.conditions import (
    MaxMessageTermination,
    TimeoutTermination,
    TokenUsageTermination
)

# Kombinierte Abbruchbedingungen
termination = (
    MaxMessageTermination(max_messages=20)
    | TimeoutTermination(timeout_seconds=3600)
    | TokenUsageTermination(max_tokens=10000)
)

Bei Erfüllung einer Bedingung endet der Dialog. Schutz gegen Endlosschleifen.

Dialogprotokoll vs Zustandsmaschine: Implizit vs explizit

AutoGen und LangGraph – grundverschiedene Philosophie.

AutoGen nutzt Conversational Programming:

• ConversableAgent: dialogfähige Agent-Basisklasse
• GroupChat: mehrere Agenten in einen Gruppenchat
• GroupChatManager: entscheidet nächsten Sprecher (Round-Robin, Auto-Auswahl, eigene Strategie)

Agenten als chatende Entitäten, Zusammenarbeit per natürlicher Sprache. Zustand implizit im Dialogfluss, weniger explizit als LangGraph.

LangGraph nutzt State Machine:

• State TypedDict: explizite Zustandsstruktur
• Node: Verarbeitungslogik pro Knoten
• Edge: Verbindungen und bedingte Verzweigungen

Jeder Schritt: wie sich der Zustand ändert, wohin als Nächstes – alles explizit definiert.

AutoGen für flexible Dialogflüsse – unklar, wer als Nächstes spricht, Agenten verhandeln frei.

LangGraph für präzise Kontrolle – klare Verzweigungen, vorhersagbare Pfade.

Checkpoint-Serialisierung (AgentChat.NET)

AutoGens Checkpoint-Fähigkeit über Serialisierung.

Laut GitHub PR #5841 unterstützt AgentChat.NET Speichern/Laden:

# Zustand in Datei speichern
team.save_state("checkpoint.json")

# Aus Datei wiederherstellen
team.load_state("checkpoint.json")

Datei-Serialisierung, keine Datenbank-Persistenz. Für Einzelserver, verteiltes Deployment braucht zusätzliche Anpassung.

Beobachtbarkeit: AutoGen nutzt OpenTelemetry-Dreiklang Logs, Metrics, Traces. Event-Stream-Monitoring + Replay-Debugging erleichtert Problemlokalisierung.

Kernvergleich und Technologieauswahl: 12-Dimensionen-Quantifizierung

Framework wählen wie Partner wählen – kein bestes, nur passendstes.

LangGraph und AutoGen repräsentieren zwei Agent-Routen: zustandsmaschinenorientierte Workflow-Orchestrierung vs dialogorientierte Multi-Rollen-Kollaboration.

12-Dimensionen-Vergleichstabelle

Dimension	LangGraph	AutoGen	Punktedifferenz
Zustandsverwaltungsmodell	Explizites State TypedDict	Impliziter Dialogfluss	LangGraph +2
Checkpoint-Mechanismus	Native Unterstützung, automatisch pro Knoten	Roadmap, Serialisierung	LangGraph +3
Wiederherstellungsfähigkeit	Super-Step-Wiederherstellung	Dialog-Rollback (in Entwicklung)	LangGraph +2
Abbruchkontrolle	Conditional Edge	TerminationCondition-Klasse	Unentschieden
Persistenzmedium	Memory/SQLite/Postgres/Redis	Datei-Serialisierung	LangGraph +2
Time Travel	Beliebiger historischer Rollback	Replay-Wiedergabe	LangGraph +1
Human-in-the-Loop	interrupt() + Command(resume=)	UserProxyAgent	LangGraph +1
Verteilte Unterstützung	PostgresSaver nativ	Ereignisgesteuerte Architektur	LangGraph +1
Entwicklungsflexibilität	Feinkörnige Kontrolle, State+Edge nötig	Dialoggetrieben, schneller Prototyp	AutoGen +1
Lernkurve	Hoch, Graph-Zustandsmaschine	Mittel, Dialogmodell	AutoGen +1
API-Stabilität	LangChain-Ökosystem stabil	v0.2 bis v0.5 Migration	LangGraph +2
Produktionsreife	⭐⭐⭐⭐⭐	⭐⭐⭐	LangGraph +2

Gesamt: LangGraph Zustandsverwaltung führt (+14 Punkte), AutoGen Dialogflexibilität (+2 Punkte).

Das heißt nicht LangGraph ist besser – LangGraph passt besser zu präziser Zustandskontrolle. AutoGen zu flexibler Dialog-Kollaboration.

Entscheidungsablauf für Einsatzszenarien

Wie wählen? Nach Ihren Anforderungen.

Anforderungsanalyse
  ↓
Klare bedingte Verzweigungen?
  ├─ Ja → LangGraph
  └─ Nein → Multi-Agent-freie Verhandlung nötig?
      ├─ Ja → AutoGen
      └─ Nein → Lange Tasks mit Fehlertoleranz?
          ├─ Ja → LangGraph
          └─ Nein → Schneller Prototyp?
              ├─ Ja → AutoGen
              └─ Nein → Standard LangGraph (Produktion)

LangGraph-Vorteilsszenarien

LangGraph passt zu:

1. Komplexe bedingte Verzweigungs-Workflows

Kundenservice-Tickets: Problemtyp erkennen → verschiedene Pfade → Ergebnis zusammenführen. Conditional Edge für präzise Steuerung.

2. Lange Tasks mit präziser Zustandskontrolle

Literaturrecherche-Agent: 10 Datenbankaufrufe, 200 Zusammenfassungen, Übersichtsbericht. 3 Stunden Laufzeit, bei Absturz Checkpoint-Wiederherstellung. Super-Step-Wiederherstellung ohne Wiederholung abgeschlossener Knoten.

3. Human-in-the-Loop-Review in Produktion

Vertragsprüfung, sensible E-Mails – Entwurf, Pause, menschliche Bestätigung. interrupt() + Command(resume=) für elegante Pause/Fortsetzung.

4. Time-Travel-Debugging

Bug reproduzieren, A/B-Tests – zu beliebigem historischen Stand rollback, Verzweigungen erkunden. Checkpoint-Sequenz checkout zu jedem Knoten.

5. Verteilte hochparallele Agent-Systeme

Kundenservice: Multi-Instanz, geteilter Zustand. PostgresSaver nativ verteilt, keine Zustandskonkurrenz.

AutoGen-Vorteilsszenarien

AutoGen passt zu:

1. Multi-Agent-freie Dialogverhandlung

Detektiv-Rollenspiel, Debatten – unklar wer als Nächstes spricht, Agenten verhandeln frei. GroupChat Auto-Auswahl, flexibler Dialogfluss.

2. Schneller Prototyp

Konzept-Demo – schnell aufbauen, kein State+Edge. Dialoggetrieben, schneller Einstieg.

3. Rollenspiel-Kollaboration

Copywriter + Design + Marketing – verschiedene Rollen, simuliertes Teamgespräch.

4. Code-Generierung + Ausführungs-Schleife

Code Executor + UserProxyAgent – Code generieren, ausführen, Feedback, korrigieren. AutoGen unterstützt das nativ.

5. Flexible Dialogflüsse

Nächster Schritt unklar – GroupChatManager entscheidet Sprecher, kein vorgegebener Ablauf.

Praxis-Code: Gleiche Anforderung in beiden Frameworks

Gleiche Anforderung – Implementierungsunterschiede im Vergleich.

Anforderung: Langer Literaturrecherche-Agent

Aufgabe:

• 10 aufeinanderfolgende Aufrufe akademischer Datenbank-APIs
• 200 Literaturzusammenfassungen
• Übersichtsbericht generieren

Laufzeit: ca. 3 Stunden

Fehlertoleranz:

• Timeout an Datenbankschnittstelle in Schritt 7
• Checkpoint-Wiederherstellung ohne Wiederholung der Schritte 1–6

Human-in-the-Loop:

• Pause nach Entwurf
• Endversion nach menschlicher Bestätigung

LangGraph-Implementierung

from langgraph.checkpoint.sqlite import SqliteSaver
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from operator import add

# State-Struktur definieren
class ResearchState(TypedDict):
    papers: Annotated[list, add]  # Akkumulieren, nicht überschreiben
    summaries: Annotated[list, add]
    draft: str
    final_report: str
    step: int
    human_approved: bool

# Knotenfunktionen definieren
def fetch_papers(state: ResearchState):
    """Akademische Datenbank-API aufrufen"""
    step = state["step"]
    papers = call_database_api(step)  # Angenommener API-Aufruf
    return {"papers": papers, "step": step + 1}

def summarize_papers(state: ResearchState):
    """Literaturzusammenfassungen generieren"""
    papers = state["papers"]
    summaries = generate_summaries(papers)  # Angenommene Zusammenfassung
    return {"summaries": summaries}

def generate_draft(state: ResearchState):
    """Entwurf generieren"""
    summaries = state["summaries"]
    draft = generate_report(summaries)  # Angenommene Berichtsgenerierung
    return {"draft": draft}

def human_review(state: ResearchState):
    """Menschliche Prüfung (wartet nach interrupt auf resume)"""
    return {"human_approved": True}

def generate_final(state: ResearchState):
    """Endversion generieren"""
    draft = state["draft"]
    final_report = refine_report(draft)
    return {"final_report": final_report}

# Graph aufbauen
graph = StateGraph(ResearchState)

# Knoten hinzufügen
graph.add_node("fetch", fetch_papers)
graph.add_node("summarize", summarize_papers)
graph.add_node("draft", generate_draft)
graph.add_node("review", human_review)
graph.add_node("final", generate_final)

# Kanten definieren
graph.add_edge("fetch", "summarize")
graph.add_edge("summarize", "draft")
graph.add_edge("draft", "review")
graph.add_edge("review", "final")
graph.add_edge("final", END)

# Einstiegspunkt setzen
graph.set_entry_point("fetch")

# Checkpointer hinzufügen (Kern)
checkpointer = SqliteSaver.from_conn_string("research_checkpoints.db")
compiled_graph = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=["review"]  # Pause vor review-Knoten
)

# Task ausführen
config = {"configurable": {"thread_id": "research-session-001"}}
result = compiled_graph.invoke({"step": 0}, config)

# Nach Fehler in Schritt 7 wiederherstellen
# Gleiche thread_id, überspringt automatisch Schritte 1–6
recovered_state = compiled_graph.invoke({"step": 7}, config)

# Human-in-the-Loop-Fortsetzung
# Pause nach Entwurf, nach Bestätigung weiter
compiled_graph.invoke(
    Command(resume={"human_approved": True}),
    config
)

Kernmerkmale:

• SqliteSaver speichert State nach jedem Knoten automatisch
• thread_id isoliert Sessions
• Wiederherstellung überspringt ausgeführte Knoten (via channel_versions)
• interrupt_before für Human-in-the-Loop-Pause

AutoGen-Implementierung

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.conditions import (
    MaxMessageTermination,
    TimeoutTermination,
    TokenUsageTermination
)
from autogen_core.models import ChatCompletionClient

# Agent definieren
research_agent = AssistantAgent(
    name="researcher",
    model_client=ChatCompletionClient(model="gpt-4"),
    system_message="Du bist ein Assistent für Literaturrecherche.\
        Rufe Datenbanken auf, fasse zusammen, erstelle Berichte.\
        Sage 'TERMINATE' wenn fertig."
)

human_agent = AssistantAgent(
    name="human_reviewer",
    model_client=ChatCompletionClient(model="gpt-4"),
    system_message="Du bist Prüfer. Sage 'APPROVED' oder 'REJECT' nach Entwurfsprüfung."
)

# Abbruchbedingungen (gegen Endlosschleifen)
termination = (
    MaxMessageTermination(max_messages=50)
    | TimeoutTermination(timeout_seconds=10800)  # 3 Stunden
    | TokenUsageTermination(max_tokens=50000)
    | TextMentionTermination(text="TERMINATE")
)

# Team aufbauen
team = RoundRobinGroupChat(
    participants=[research_agent, human_agent],
    termination_condition=termination
)

# Task ausführen
async def run_research():
    result = await team.run(
        task="200 Literaturzusammenfassungen erstellen und Übersichtsbericht generieren"
    )
    return result

# Checkpoint speichern (AgentChat.NET)
team.save_state("research_checkpoint.json")

# Aus Checkpoint wiederherstellen
team.load_state("research_checkpoint.json")

# Fortsetzen
async def resume_research():
    result = await team.run()
    return result

Kernmerkmale:

• TerminationCondition gegen Endlosschleifen (Schutzmechanismus)
• Save/Load in Datei (Serialisierung)
• Ereignisgesteuerte Architektur für verteiltes Deployment
• Dialogprotokoll: Agenten kooperieren per natürlicher Sprache

Vergleichszusammenfassung

Merkmal	LangGraph	AutoGen
Zustandsdefinition	Explizites TypedDict	Impliziter Dialogfluss
Checkpoint	Automatisch pro Knoten (Datenbank)	Datei-Serialisierung
Wiederherstellung	Super-Step, überspringt ausgeführte Knoten	Dialog-Rollback
Human-in-the-Loop	interrupt-Pause + resume-Fortsetzung	UserProxyAgent
Abbruchkontrolle	Conditional Edge	TerminationCondition
Codeumfang	ca. 60 Zeilen (State+Edge nötig)	ca. 30 Zeilen (dialoggetrieben)

LangGraph: Feinkörnige Kontrolle für präzise Zustandsverwaltung.

AutoGen: Schneller Prototyp für flexible Dialog-Kollaboration.

Produktions-Deployment: Vom Entwicklungs- zum Produktionsbetrieb

LangGraph Produktions-Deployment

Persistenz:

PostgresSaver + RedisSaver kombiniert.

PostgreSQL als persistente Speicherung, nativ verteilt. Redis als Cache für hohe Parallelität.

from langgraph.checkpoint.postgres import PostgresSaver
from langgraph.checkpoint.redis import RedisSaver

# Produktionskonfiguration
postgres_saver = PostgresSaver.from_conn_string(
    "postgresql://user:pass@host:5432/db"
)
redis_saver = RedisSaver.from_conn_string(
    "redis://host:6379/0"
)

# Kombiniert: Redis-Cache + Postgres-Persistenz
compiled_graph = graph.compile(
    checkpointer=postgres_saver
)

Beobachtbarkeit:

LangSmith Tracing + OpenTelemetry-Integration.

LangSmith für Aufrufketten – welcher Knoten langsam, welcher Token-Verbrauch hoch. OpenTelemetry für bestehendes Monitoring.

Performance-Optimierung:

Streaming – Nutzer sieht sofort ersten Token, Latenzwahrnehmung <1 Sekunde.

Parallele Tool-Aufrufe – LangGraph nativ unterstützt.

Prompt-Vorkompilierung – ca. 30 % weniger LLM-Inferenzzeit.

Kostenoptimierung:

Strategie	Kostensenkung	Einsatz
Prompt-Komprimierung	30–50 %	Allgemein
Multi-Provider-Routing	40–60 %	Produktions-Failover
Cache-Mechanismus	50–80 %	Wiederholte Abfragen

Multi-Provider-Routing ist Produktions-Standard. API Gateway Failover: GPT-4 ausgefallen → Wechsel zu Claude, Kosten -40 %.

AutoGen Produktions-Deployment

Beobachtbarkeit:

OpenTelemetry-Dreiklang – Logs, Metrics, Traces.

• EventLogger + strukturierte Logs: Problemlokalisierung, Audit
• OpenTelemetry Meter: Performance, Kapazitätsplanung
• OpenTelemetry Tracer: Aufrufketten, Latenzoptimierung

from autogen_core.telemetry import (
    enable_telemetry,
    EventLogger
)

# Beobachtbarkeit aktivieren
enable_telemetry(
    logger=EventLogger(),
    meter=OpenTelemetryMeter(),
    tracer=OpenTelemetryTracer()
)

Event-Stream-Monitoring:

Replay-Debugging – alle Agent-Aktionen als Event-Stream, Wiedergabe zur Problemnachstellung.

Verteilte Anpassung:

Ereignisgesteuerte Architektur nativ verteilt. Agent-Nachrichten über Events, keine Zustandskonkurrenz.

Kostenkontrolle:

TokenUsageTermination – automatischer Abbruch bei Budgetlimit.

from autogen_agentchat.conditions import TokenUsageTermination

# Kosten-Schutzmechanismus
termination = TokenUsageTermination(max_tokens=10000)

Strukturierte Logs für Token-Analyse – welche Dialoge teuer, welcher Agent kostet viel.

Produktions-Deployment-Vergleich

Dimension	LangGraph	AutoGen
Persistenz	PostgresSaver verteilt	Datei-Serialisierung (Anpassung nötig)
Beobachtbarkeit	LangSmith Tracing	OpenTelemetry-Dreiklang
Kostenkontrolle	Multi-Provider-Routing	TokenUsageTermination
Performance	Streaming + parallele Tools	Event-Stream-Monitoring
Verteilt	PostgresSaver nativ	Ereignisgesteuert

Kernlektion: Produktion braucht AI Gateway

Ob LangGraph oder AutoGen – Produktion braucht AI Gateway.

Warum?

1. Multi-Provider-Failover

API ausgefallen → automatischer Wechsel. GPT-4 down → Claude. Single Point of Failure eliminiert.

2. Kostenmonitoring

Welcher Agent verbraucht viel, welcher Dialog teuer – Echtzeit. Budgetüberschreitung → automatischer Abbruch.

3. Rate Limiting

Schutz vor API-Drosselung. Anfragen in Warteschlange, automatischer Retry.

4. Log-Tracing

Alle Aufrufe zentral. Problemlokalisierung, Audit.

AI Gateway ist keine Option – Pflicht für produktionsreife Agenten.

Fazit

LangGraph und AutoGen repräsentieren zwei Agent-Routen.

LangGraph: Zustandsmaschinenorientierte Workflow-Orchestrierung. Explizites State+Node+Edge, jeder Schritt kontrollierbar. Native Checkpoint-Unterstützung, Wiederherstellung ohne Wiederholung. Für komplexe Verzweigungen, lange Tasks, verteiltes Deployment.

AutoGen: Dialogorientierte Multi-Rollen-Kollaboration. Agenten verhandeln per natürlicher Sprache, flexibler Dialogfluss. Abbruchbedingungen gegen Endlosschleifen. Für schnelle Prototypen, freie Multi-Agent-Verhandlung, Rollenspiel-Szenarien.

Auswahl ist nicht „welches besser“, sondern „welches passt zu Ihrem Szenario“.

Klare bedingte Verzweigungen? LangGraph. Multi-Agent-freie Verhandlung? AutoGen. Lange Tasks mit Fehlertoleranz? LangGraph. Schneller Prototyp? AutoGen.

Beide Frameworks – beide mit Fallstricken. AutoGen: Zustand unkontrollierbar, API-Migration Code neu schreiben. LangGraph: Zustandsgraph über hundert Zeilen.

Kernlektion: Produktion braucht AI Gateway. Multi-Provider-Failover, Kostenmonitoring, Rate Limiting – diese drei Funktionen sind die Basis für stabilen Agent-Betrieb.

Nächster Schritt: Komplexer Workflow → LangGraph. Schneller Multi-Agent-Prototyp → AutoGen. Dann „LangGraph Zustandsverwaltung in der Praxis“ (Serie Nr. 39) für Checkpoint-Praxis im Detail.