AI Agents im Unternehmen: Multi-Agent mit LangGraph

Warum Multi-Agent-Systeme die nächste Stufe der KI-Integration sind

Single-Prompt-LLM-Aufrufe haben in den letzten zwei Jahren viele Unternehmensprozesse automatisiert. Doch sobald Aufgaben mehrere Schritte, externe Tools und Kontextwechsel erfordern, stoßen lineare Pipelines an ihre Grenzen. Multi-Agent-Systeme mit Frameworks wie LangGraph lösen genau dieses Problem: Mehrere spezialisierte KI-Agenten koordinieren sich gegenseitig, rufen Werkzeuge auf und treffen Entscheidungen über den nächsten Schritt im Workflow.

Für CTOs und IT-Leiter bedeutet das einen Paradigmenwechsel: Statt monolithischer Prompt-Engineering-Lösungen entstehen komponierbare KI-Workflows, die sich wie klassische Microservices entwerfen, testen und betreiben lassen. In diesem Artikel zeigen wir, wie Sie produktionsreife Multi-Agent-Systeme architektonisch sauber, DSGVO-konform und wartbar im Enterprise-Umfeld umsetzen.

Was sind AI Agents überhaupt?

Ein AI Agent ist mehr als ein einfacher Chatbot. Er besteht aus drei Kernkomponenten:

• Reasoning-Layer: Ein LLM (z.B. Claude, GPT-4 oder Llama 3) trifft Entscheidungen über den nächsten Schritt
• Tool-Layer: Funktionen, APIs und Datenquellen, die der Agent aufrufen kann
• Memory-Layer: Kurzzeit- und Langzeitgedächtnis über Vector Stores oder strukturierte Speicher

Während ein einzelner Agent für einfache Aufgaben genügt, bröckelt das Konzept bei komplexen Geschäftsprozessen. Ein Agent, der gleichzeitig SAP-Daten abruft, Rechnungen klassifiziert, Freigaben einholt und in Salesforce schreibt, wird unzuverlässig. Die Lösung: Aufteilung in spezialisierte Agenten, die über einen Orchestrator koordiniert werden.

Single-Agent vs. Multi-Agent: Wann lohnt sich der Aufwand?

Ein Multi-Agent-System lohnt sich, wenn mindestens zwei der folgenden Bedingungen zutreffen:

• Der Workflow umfasst mehr als 5 Schritte mit unterschiedlichen Datenquellen
• Verschiedene Aufgaben benötigen unterschiedliche Modelle (Vision, Embeddings, Code)
• Es existieren parallele Verarbeitungspfade
• Menschliche Freigaben (Human-in-the-Loop) müssen integriert werden
• Audit-Logs und Erklärbarkeit sind regulatorisch gefordert

LangGraph: Warum dieses Framework?

LangGraph ist eine Erweiterung von LangChain und modelliert Agent-Workflows als gerichtete Graphen. Knoten sind Funktionen oder Agenten, Kanten beschreiben die möglichen Übergänge. Anders als bei klassischen LangChain-Chains ist der Kontrollfluss explizit, deterministisch testbar und unterstützt Schleifen, Verzweigungen sowie persistente State-Snapshots.

Im Vergleich zu CrewAI oder AutoGen bietet LangGraph drei entscheidende Vorteile für Enterprise-Szenarien:

1. Persistenter State: Workflows lassen sich pausieren, wieder aufnehmen und nach Fehlern an exakter Stelle fortsetzen
2. Streaming-First: Zwischenergebnisse können in Echtzeit an UIs gestreamt werden
3. Time-Travel-Debugging: Jeder State-Übergang ist nachvollziehbar – essentiell für Compliance

Code-Beispiel: Ein einfacher Multi-Agent-Graph

Folgendes Beispiel zeigt einen Rechnungsverarbeitungs-Workflow mit drei Agenten: einem Extractor, einem Validator und einem Approver.

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

class InvoiceState(TypedDict):
    raw_pdf: bytes
    extracted_data: dict
    validation_errors: list
    approval_status: str
    audit_log: Annotated[list, operator.add]

def extract_node(state: InvoiceState) -> dict:
    data = extractor_agent.invoke(state["raw_pdf"])
    return {
        "extracted_data": data,
        "audit_log": [{"step": "extract", "ts": now()}]
    }

def validate_node(state: InvoiceState) -> dict:
    errors = validator_agent.invoke(state["extracted_data"])
    return {"validation_errors": errors}

def route_after_validation(state: InvoiceState) -> str:
    return "approve" if not state["validation_errors"] else "human_review"

workflow = StateGraph(InvoiceState)
workflow.add_node("extract", extract_node)
workflow.add_node("validate", validate_node)
workflow.add_node("approve", approver_agent)
workflow.add_node("human_review", human_in_the_loop)

workflow.set_entry_point("extract")
workflow.add_edge("extract", "validate")
workflow.add_conditional_edges("validate", route_after_validation)
workflow.add_edge("approve", END)

app = workflow.compile(checkpointer=postgres_checkpointer)

Der entscheidende Punkt: Der checkpointer persistiert nach jedem Knoten den State in PostgreSQL. Fällt der Worker aus, kann der Workflow exakt dort fortgesetzt werden, wo er unterbrochen wurde.

Architektur-Patterns für produktive Multi-Agent-Systeme

1. Supervisor-Pattern

Ein Supervisor-Agent erhält die Eingabe und delegiert an spezialisierte Sub-Agenten. Jeder Sub-Agent berichtet Ergebnisse zurück, der Supervisor entscheidet über den nächsten Schritt. Vorteil: Klare Verantwortlichkeiten, einfaches Debugging. Nachteil: Der Supervisor wird zum Bottleneck.

2. Hierarchical Teams

Für komplexe Domänen werden Sub-Agenten zu Teams mit eigenen Team-Supervisoren zusammengefasst. Ein Top-Level-Supervisor delegiert an die Teams. Dieses Pattern eignet sich für Szenarien wie automatisierte Recherche, bei denen ein Research-Team und ein Writing-Team eigenständig arbeiten.

3. Network-Pattern (Swarm)

Agenten kommunizieren direkt miteinander, ohne zentralen Koordinator. Maximale Flexibilität, aber schwer zu debuggen und nur für explorative Use-Cases empfehlenswert.

DSGVO-konforme Implementierung

Sobald Multi-Agent-Systeme personenbezogene Daten verarbeiten, treten regulatorische Anforderungen in den Vordergrund. Die folgenden Punkte sind in jedem Enterprise-Setup zu klären:

• Datenresidenz: Verwenden Sie Modelle in EU-Rechenzentren (Azure OpenAI EU, AWS Bedrock Frankfurt) oder selbst gehostete Open-Source-Modelle wie Mistral oder Llama 3 auf eigener GPU-Infrastruktur
• Pseudonymisierung vor LLM-Aufruf: Personenbezogene Daten werden vor dem Prompt durch Tokens ersetzt und nach der Antwort rückersetzt (Reversible Anonymization)
• Audit-Trail: Jeder Agenten-Schritt wird mit Input, Output, Modell-Version und Timestamp protokolliert
• Rechte-Management: Welcher Agent darf welche Tools aufrufen? Implementieren Sie ein RBAC-System pro Agent-Identität
• Löschkonzept: Vector Stores müssen Right-to-Be-Forgotten unterstützen – das ist nicht trivial bei Embeddings

Pseudonymisierungs-Beispiel

import re
from presidio_analyzer import AnalyzerEngine
from presidio_anonymizer import AnonymizerEngine

analyzer = AnalyzerEngine()
anonymizer = AnonymizerEngine()

def pseudonymize_for_llm(text: str) -> tuple[str, dict]:
    results = analyzer.analyze(
        text=text,
        entities=["PERSON", "EMAIL_ADDRESS", "PHONE_NUMBER", "IBAN_CODE"],
        language="de"
    )
    anonymized = anonymizer.anonymize(text=text, analyzer_results=results)
    return anonymized.text, anonymized.items

Tool-Integration: Der wahre Mehrwert

Ein Agent ist nur so nützlich wie seine Werkzeuge. Für Enterprise-Szenarien sind folgende Tool-Kategorien relevant:

• Strukturierte Datenquellen: SQL-Datenbanken, SAP, Salesforce über typisierte Schemata
• Unstrukturierte Datenquellen: SharePoint, Confluence, S3 über RAG-Pipelines mit Vector Stores
• Action-Tools: E-Mail-Versand, Ticket-Erstellung, Workflow-Trigger
• Code-Execution: Sandboxed Python-Environments für Datenanalyse-Aufgaben

Wichtig: Tools müssen idempotent sein, klare Fehlermeldungen liefern und ein definiertes Schema haben. LLMs treffen schlechtere Entscheidungen, wenn Tool-Beschreibungen unklar sind.

Observability: Ohne Monitoring kein Produktivbetrieb

Klassisches APM reicht für Multi-Agent-Systeme nicht aus. Sie benötigen LLM-spezifisches Tracing, das folgende Metriken erfasst:

• Token-Verbrauch pro Agent und pro Workflow-Run
• Latenz pro LLM-Aufruf inkl. Modell-Cold-Start
• Tool-Aufrufe mit Input-/Output-Schema-Validierung
• Halluzinationsraten über Eval-Suiten
• Cost-Attribution pro Mandant in Multi-Tenant-Szenarien

Tools wie LangSmith, Arize Phoenix oder Langfuse (selbst hostbar, DSGVO-konform) liefern diese Funktionalität out-of-the-box. Für regulierte Branchen empfehlen wir die selbst gehostete Variante in Kombination mit OpenTelemetry-Export an bestehende SIEM-Systeme.

Deployment-Strategien

Containerisierung

LangGraph-Workflows lassen sich problemlos als FastAPI-Service in Docker-Containern deployen. Für horizontale Skalierung empfehlen wir Kubernetes mit folgender Topologie:

• API-Pods für synchrone Anfragen (kurze Workflows)
• Worker-Pods mit Celery oder ARQ für asynchrone Long-Running Workflows
• Redis als Message-Broker und Caching-Layer
• PostgreSQL als persistenter State-Store für Checkpointer
• pgvector oder Qdrant als Vector Store

Cost-Optimierung durch Modell-Routing

Nicht jeder Schritt benötigt das größte Modell. Ein Router-Agent kann Aufgaben nach Komplexität klassifizieren und an günstigere Modelle (Haiku, Mistral 7B) oder teurere Modelle (Opus, GPT-4) delegieren. In unseren Kundenprojekten reduziert das die Inferenz-Kosten regelmäßig um 60–80% bei gleichbleibender Qualität.

Typische Fallstricke und wie Sie sie vermeiden

• Endlosschleifen: Setzen Sie immer ein Recursion-Limit im Graph (compile(recursion_limit=25))
• Context-Bloat: Lange Conversations sprengen das Context Window. Nutzen Sie Summarization-Knoten zwischen Iterationen
• Prompt-Injection: Sanitisieren Sie alle externen Inputs, besonders aus E-Mails und Web-Scrapes
• Vendor-Lock-in: Abstrahieren Sie LLM-Aufrufe über LiteLLM oder eigene Adapter
• Fehlende Evaluations: Bauen Sie Eval-Datasets parallel zur Entwicklung auf, nicht nachträglich

Praxisbeispiel: Vom Proof-of-Concept zum Produktivsystem

Ein typisches Innosirius-Projekt durchläuft vier Phasen:

1. Discovery (1–2 Wochen): Workflow-Mapping, Tool-Inventar, Datenquellen-Analyse
2. Prototyping (3–4 Wochen): Single-Agent-PoC mit reduziertem Scope, Eval-Setup
3. Productionization (6–8 Wochen): Multi-Agent-Architektur, Monitoring, DSGVO-Compliance, CI/CD
4. Scaling (laufend): Cost-Optimierung, neue Use-Cases, Modell-Updates

Fazit: Multi-Agent-Systeme sind reif für den Enterprise-Einsatz

LangGraph und vergleichbare Frameworks haben den Sprung von experimentellen Tools zu produktionsreifen Plattformen geschafft. Mit klarer Architektur, sauberer Tool-Integration und konsequentem Monitoring lassen sich heute KI-Workflows bauen, die früher manuell oder gar nicht möglich waren – und das DSGVO-konform und Made in Germany.

Der entscheidende Erfolgsfaktor liegt nicht im Framework, sondern in der Software-Engineering-Disziplin: Versionierte Prompts, automatisierte Evaluations, observability-first Design und sauber abgegrenzte Verantwortlichkeiten zwischen den Agenten.

Sie planen ein Multi-Agent-Projekt im eigenen Unternehmen? Innosirius unterstützt CTOs und IT-Leiter bei Architektur, Implementierung und Betrieb produktiver KI-Systeme. Vereinbaren Sie ein unverbindliches Strategiegespräch – wir zeigen Ihnen anhand Ihres konkreten Use-Cases, wie sich Multi-Agent-Systeme rentabel und compliant umsetzen lassen.