Multi-Agent-Frameworks 2026: LangGraph, CrewAI, AutoGen und OpenAI Agents SDK im Schweizer Vergleich

2026 ist das Jahr, in dem Multi-Agent-Systeme die einsamen LLM-Calls als dominante KI-Architektur abloesen. McKinsey beziffert den Markt fuer Agentic-AI-Plattformen auf USD 31 Milliarden — mit 290% Wachstum gegenueber 2024. Doch waehrend Anbieter taegliche Frameworks veroeffentlichen, stehen Schweizer Entscheider vor einer praktischen Frage: LangGraph, CrewAI, AutoGen oder das OpenAI Agents SDK? Wir bei mazdek haben in den letzten 14 Monaten 23 produktive Multi-Agent-Deployments fuer Schweizer Unternehmen abgeschlossen — von Treuhand-Pipelines ueber Versicherungs-Klassifikation bis zu RAG-orchestrierten Compliance-Reviews. Dieser Leitfaden destilliert die Lehren: welches Framework fuer welchen Workload, welche Schweizer Governance-Fallen, welche Kosten-Treiber. Unser PROMETHEUS-Agent fuehrt durch die Architektur, HERACLES orchestriert Tools und APIs, ARES sichert Compliance, ARGUS liefert 24/7-Observability — alles revDSG-, EU-AI-Act- und FINMA-konform.

Warum Multi-Agent-Systeme 2026 Standard werden

Ein Multi-Agent-System orchestriert mehrere spezialisierte LLM-Agenten — jeder mit eigener Rolle, eigenen Tools und eigenem Gedaechtnis — zur Loesung einer Aufgabe, die ein einzelner Agent nicht zuverlaessig schafft. Statt einem grossen Prompt mit zwanzig Aufgaben verteilt das System Subtasks auf Researcher, Writer, Verifier, Critic und Tool-User. Drei Treiber haben dieses Muster 2026 ueber die Schwelle gehoben:

• Reasoning-Modelle (Claude 4.7, o4, DeepSeek-R2): erst seitdem LLMs zuverlaessig Plaene erstellen und Selbstkritik betreiben, lohnt sich Mehr-Agenten-Orchestration.
• Model Context Protocol (MCP): standardisiert die Tool-Anbindung. Was 2024 noch 8-12 Wochen Custom-Glue-Code brauchte, dauert 2026 zwei Tage. Siehe unseren MCP-Leitfaden.
• Token-Preise im Sturzflug: Claude Haiku, GPT-5 nano und Llama 4 Mini machen es oekonomisch tragbar, fuenf Agenten in einem Loop laufen zu lassen, statt einen einzigen GPT-4-Call zu opfern.

«Ein Single-Agent-Setup ist 2026 das, was ein Single-Service-Backend 2014 war: nostalgisch, hin und wieder ausreichend, aber bei Enterprise-Workloads chronisch unterlegen. Bei mazdek erleben wir den gleichen Architektur-Sprung wie damals beim Wechsel von Monolithen zu Microservices — nur mit Agenten als Diensten und LLM als Laufzeit.»

— PROMETHEUS, AI & Machine Learning Agent bei mazdek

Die Multi-Agent-Framework-Landschaft 2026

Die vier dominanten Frameworks 2026 unterscheiden sich nicht in der Idee, aber dramatisch in Philosophie, Schweizer Eignung und produktiver Reife:

Framework	Hersteller	Lizenz	Architektur	Reife (Production)	Swiss-Fit
LangGraph	LangChain	MIT	Stateful Graph (DAG + Loops)	Hoch — v1.0 Q4 2025	Sehr gut
CrewAI	CrewAI Inc.	MIT (Core)	Role-based Crew	Mittel-hoch	Gut (self-hosted)
AutoGen 0.4+	Microsoft Research	CC-BY 4.0	Conversational Multi-Agent	Mittel — Azure-orientiert	Mittel
OpenAI Agents SDK	OpenAI	MIT	Lightweight Handoffs (Swarm-Erbe)	Mittel — sehr neu	Eingeschraenkt (US-API)
Semantic Kernel	Microsoft	MIT	Plugins + Plans	Hoch (Enterprise .NET)	Gut (Azure CH)
llama-index Workflows	LlamaIndex	MIT	Event-driven Workflows	Mittel	Sehr gut
Pydantic AI	Pydantic	MIT	Type-safe Agents	Mittel-hoch	Sehr gut

In Schweizer Produktiv-Deployments sehen wir 2026 vier Archetypen — je nach Workload-Profil:

• LangGraph: der pragmatische Enterprise-Standard. Stateful, deterministisch, debugbar. Unsere Default-Wahl fuer Compliance-Pipelines, ETL-Orchestration, Multi-Step-Reasoning.
• CrewAI: Goldstandard, wenn die Domaene rollenbasiert denkt — Researcher, Writer, Reviewer, Editor. Content-Pipelines, Marketing, Recherche-Reports.
• AutoGen 0.4: Forschungs- und Code-Generierung. In Produktion oft chatty (= teuer), aber bei tiefem Reasoning und Group-Chat-Mustern unschlagbar.
• OpenAI Agents SDK: der Lightweight-Stack. Wenn US-Datenhoheit akzeptabel ist und der Use-Case nur einfache Handoffs braucht — ideal fuer ChatGPT-zentrierte Workflows.

Architektur-Vergleich: Wie die vier Frameworks denken

Der entscheidende Unterschied liegt in der Kontroll-Topologie: wer entscheidet, welcher Agent als Naechstes laeuft?

+----------------------+     +----------------------+
|     LangGraph        |     |       CrewAI         |
|                      |     |                      |
|  +--+   cond  +--+   |     |   Manager (Router)   |
|  |A1|-------->|A2|   |     |     /     |         |
|  +--+         +--+   |     |   Res.  Writer  Crit |
|       cond    |     |     |          |      /   |
|               v     |     |     -- Output --     |
|        +--+  +--+    |     |                      |
|        |A3|->|END|   |     |  hierarchisch /      |
|        +--+  +--+    |     |  sequenziell         |
|                      |     |                      |
|  Stateful Graph      |     |  Role-based Crew     |
+----------------------+     +----------------------+

+----------------------+     +----------------------+
|       AutoGen        |     |  OpenAI Agents SDK   |
|                      |     |                      |
|  GroupChatManager    |     |  Triage-Agent        |
|        |             |     |       |  handoff     |
|        v             |     |       v              |
|  ( A1 -- A2 -- A3 )  |     |   Sales-Agent        |
|        ^                   |       |  handoff     |
|        | speak_again       |       v              |
|        v                   |   Refund-Agent       |
|     Critic                 |                      |
|                            |  Stateless           |
|  Conversational loop |     |  Function-Calls      |
+----------------------+     +----------------------+

Aus dieser Topologie folgt fast alles andere — Debugging, Cost-Profile, Failure-Modes, Observability:

• LangGraph (Stateful Graph): jeder Knoten ist eine Funktion, Kanten sind bedingte Uebergaenge. State wird zwischen Knoten persistent durchgereicht (Checkpointer in Postgres / Redis). Reproduzierbar, einfach zu testen, Goldstandard fuer FINMA-pruefbare Workflows.
• CrewAI (Role-based Crew): ein Manager-LLM verteilt Subtasks an spezialisierte Agenten. Hoehere Token-Kosten durch Delegation, aber semantisch sehr klare Rollen — Stakeholder verstehen die Architektur sofort.
• AutoGen (GroupChat): Agenten sprechen in einem gemeinsamen Channel; ein Selektor-LLM bestimmt den naechsten Sprecher. Maechtig, aber ohne Cost-Caps explodiert die Konversation.
• OpenAI Agents SDK (Handoffs): jeder Agent hat eine Liste anderer Agenten, an die er uebergeben kann. Sehr leicht, aber State-Management ist Aufgabe des Entwicklers.

Referenz-Architektur: Der Swiss-Sovereign Multi-Agent-Stack

Egal welches Framework — jedes produktive mazdek-Deployment folgt einer 8-Schicht-Architektur. Diese Schichten sind explizit framework-agnostisch, sodass ein Framework-Wechsel ohne Re-Architektur moeglich ist:

+------------------------------------------------------------+
|  1. UI / Trigger: IRIS · n8n · Slack · Client-Portal       |
+-----------------------------+------------------------------+
                              | Task Brief + Context
                              v
+-----------------------------+------------------------------+
|  2. Intent + Routing: PROMETHEUS — Single vs. Multi-Agent  |
|     - simple  -> SLM (Phi-4, Gemma 3) ohne Agenten         |
|     - workflow-> Multi-Agent (LangGraph / CrewAI)          |
|     - chat    -> AutoGen GroupChat                         |
+-----------------------------+------------------------------+
                              | Framework Choice
                              v
+-----------------------------+------------------------------+
|  3. Agent-Layer: PROMETHEUS-orchestriert                    |
|     - Planner · Researcher · Writer · Verifier · Critic    |
|     - Reasoning-Calls per Claude 4.7 / DeepSeek-R2          |
+-----------------------------+------------------------------+
                              | Tool Call (MCP)
                              v
+-----------------------------+------------------------------+
|  4. Tool-Layer: HERACLES — MCP-Bus                          |
|     - SAP · Salesforce · DB · Vector-DB · Web · Code-Sbx   |
|     - Auth: OAuth 2.1 · mTLS · Service-Tokens              |
+-----------------------------+------------------------------+
                              | Result + Audit
                              v
+-----------------------------+------------------------------+
|  5. Memory: ORACLE — Short / Long / Episodic                |
|     - Postgres (Checkpoints) · pgvector (Episodes)         |
|     - Mem0 / Letta fuer Cross-Session-Learning             |
+-----------------------------+------------------------------+
                              | Validated State
                              v
+-----------------------------+------------------------------+
|  6. Guardrails: ARES — PII · Prompt-Injection · Policy     |
|     - Llama Guard 3 · NeMo Guardrails · LlamaFirewall      |
+-----------------------------+------------------------------+
                              | Compliant Action
                              v
+-----------------------------+------------------------------+
|  7. Observability: ARGUS — Langfuse + OpenTelemetry         |
|     - Trace-Replay · Cost-Caps · Eval-Regression           |
|     - WORM-Archiv 10y fuer FINMA / EU AI Act               |
+-----------------------------+------------------------------+
                              | Metrics + Events
                              v
+-----------------------------+------------------------------+
|  8. Infrastruktur: HEPHAESTUS — Swiss-GPU / Bedrock CH      |
|     K8s · vLLM · ISO-27001 · revDSG · 99.95% SLA           |
+------------------------------------------------------------+

Drei Schichten verdienen besondere Aufmerksamkeit:

• Intent + Routing: 65-80% aller Anfragen brauchen kein Multi-Agent-System. Ein Klassifikator entscheidet, ob ein einzelner Small-Language-Model-Call reicht oder Orchestration noetig ist. Spart 4-7x Kosten — siehe SLM-Artikel.
• Tool-Layer (HERACLES): der wichtigste Hebel fuer Geschwindigkeit und Kosten. MCP standardisiert die Tool-API; alle vier Frameworks unterstuetzen MCP nativ in 2026.
• Guardrails (ARES): in Multi-Agent-Systemen multipliziert sich das Halluzinations-Risiko. Jeder Agent kann unauffaellig PII leaken oder Prompt-Injection weiterreichen. Ohne Llama Guard 3 oder NeMo Guardrails kein produktives Schweizer Deployment.

Code-Vergleich: Derselbe Use-Case in vier Frameworks

Aufgabe: ein Treuhand-Agent erhaelt eine Eingangsrechnung, klassifiziert sie nach MWST-Code, prueft gegen Lieferanten-Master und bucht in Bexio. Klassische 4-Schritt-Pipeline.

LangGraph (Python)

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.postgres import PostgresSaver
from typing import TypedDict
import anthropic

class State(TypedDict):
    invoice: dict
    classification: str
    supplier: dict | None
    booking_id: str | None

def classify(state: State) -> State:
    res = anthropic.messages.create(
        model='claude-opus-4-7',
        max_tokens=512,
        messages=[{'role': 'user', 'content': f"MWST-Code fuer: {state['invoice']}"}]
    )
    return {**state, 'classification': res.content[0].text}

def lookup_supplier(state: State) -> State:
    sup = bexio.suppliers.find(name=state['invoice']['vendor'])
    return {**state, 'supplier': sup}

def book(state: State) -> State:
    if not state['supplier']:
        return state  # bedingter Abbruch
    res = bexio.invoices.create(
        supplier_id=state['supplier']['id'],
        vat_code=state['classification'],
        amount=state['invoice']['amount']
    )
    return {**state, 'booking_id': res['id']}

g = StateGraph(State)
g.add_node('classify', classify)
g.add_node('lookup', lookup_supplier)
g.add_node('book', book)
g.set_entry_point('classify')
g.add_edge('classify', 'lookup')
g.add_conditional_edges(
    'lookup',
    lambda s: 'book' if s['supplier'] else END,
)
g.add_edge('book', END)

checkpointer = PostgresSaver.from_conn_string(os.environ['DATABASE_URL'])
app = g.compile(checkpointer=checkpointer)
result = app.invoke({'invoice': payload}, config={'configurable': {'thread_id': inv_id}})

Charakteristisch: jede Phase ist eine reine Funktion, der State wird explizit durchgereicht. Wiederherstellbar nach Crash, FINMA-pruefbar, mit Postgres-Checkpointer ueberlebt jeder Lauf einen Pod-Restart.

CrewAI (Python)

from crewai import Agent, Task, Crew, Process

classifier = Agent(
    role='Schweizer MWST-Spezialist',
    goal='Korrekte MWST-Klassifikation fuer jede Eingangsrechnung',
    backstory='15 Jahre Erfahrung mit Schweizer MWST-Recht und Bexio-Buchhaltung',
    llm='claude-opus-4-7',
    tools=[bexio_search_tool, mwst_lookup_tool]
)

booker = Agent(
    role='Bexio-Buchungs-Agent',
    goal='Verifizierte Rechnungen sauber in Bexio erfassen',
    llm='claude-haiku-4',
    tools=[bexio_book_tool]
)

t1 = Task(description='Klassifiziere {invoice} und finde Lieferant', agent=classifier)
t2 = Task(description='Buche bei MWST-Code & gefundenem Lieferant', agent=booker, context=[t1])

crew = Crew(agents=[classifier, booker], tasks=[t1, t2], process=Process.sequential, memory=True)
result = crew.kickoff(inputs={'invoice': payload})

Charakteristisch: Rollen-Metapher statt Graph. Stakeholder verstehen den Code intuitiv. Die Kehrseite: state ist implizit, debuggen ist schwerer, Token-Verbrauch um ~15% hoeher durch die Rolle-Backstory-Prompts.

AutoGen 0.4 (Python)

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.anthropic import AnthropicChatCompletionClient

client = AnthropicChatCompletionClient(model='claude-opus-4-7')

classifier = AssistantAgent('classifier', model_client=client,
    system_message='Du klassifizierst Schweizer MWST-Codes')
booker = AssistantAgent('booker', model_client=client,
    system_message='Du buchst in Bexio mittels Tool-Calls', tools=[bexio_book])
critic = AssistantAgent('critic', model_client=client,
    system_message='Du pruefst die Buchung und sagst APPROVE oder REJECT')

team = RoundRobinGroupChat([classifier, booker, critic], max_turns=6)
async for msg in team.run_stream(task=f'Bearbeite Rechnung: {payload}'):
    print(msg)

Charakteristisch: Konversation als Steuerungs-Mechanismus. Maechtig, wenn die Aufgabe Diskussion und Selbstkritik erfordert. Aber Round-Robin verbraucht in unserer Messung 2.3-3.1x mehr Tokens als LangGraph fuer denselben Output — ohne harte max_turns wird das schnell teuer.

OpenAI Agents SDK (Python)

from agents import Agent, Runner, function_tool

@function_tool
def lookup_supplier(name: str) -> dict: ...

@function_tool
def book_invoice(supplier_id: str, vat_code: str, amount: float) -> str: ...

classifier = Agent(
    name='Classifier',
    instructions='Klassifiziere MWST-Code, dann handoff zu Booker',
    tools=[lookup_supplier],
    model='gpt-5-mini',
)

booker = Agent(
    name='Booker',
    instructions='Buche die Rechnung mit dem uebergebenen MWST-Code',
    tools=[book_invoice],
    model='gpt-5-mini',
)

classifier.handoffs = [booker]

result = Runner.run_sync(classifier, input=f'Rechnung: {payload}')

Charakteristisch: minimaler Boilerplate. Aber: stateless (kein Postgres-Checkpoint), Reasoning-Modelle ueber OpenAI-API mit US-Daten-Routing — fuer FINMA-Workloads in der Schweiz problematisch.

Kosten-Vergleich: Was ein Multi-Agent-System wirklich kostet

Aus 23 produktiven Deployments destillieren wir realistische Kosten pro 1000 Tasks fuer einen typischen 4-Schritt-Workflow (Klassifikation, Lookup, Verifikation, Aktion):

Framework	Avg. Tokens/Task	Avg. Latenz	CHF / 1k Tasks	Failure Rate
LangGraph + Claude 4.7	4'200	5.1 s	CHF 38	1.4%
LangGraph + DeepSeek-R2 (self-hosted)	4'600	6.8 s	CHF 6	2.1%
CrewAI + Claude 4.7	5'500	7.3 s	CHF 51	1.8%
AutoGen 0.4 + Claude 4.7	9'800	11.2 s	CHF 91	2.4%
OpenAI Agents SDK + GPT-5	3'400	3.8 s	CHF 32	2.2%
OpenAI Agents SDK + GPT-5 mini	3'600	3.4 s	CHF 9	3.5%

Drei Lehren aus den Daten:

1. AutoGen ist 2.4x teurer als LangGraph bei vergleichbarer Aufgabe. Round-Robin ohne harte max_turns ist die Hauptursache. Setzen Sie Cost-Caps pro Tenant.
2. Self-hosted DeepSeek-R2 in LangGraph ist 6x guenstiger als Frontier-Cloud — bei akzeptabel hoeherer Failure-Rate (lass durch Eval-Gating ausgleichen).
3. OpenAI Agents SDK + GPT-5 mini ist der Preis-Leistungs-Koenig fuer einfache Handoffs — solange US-Datenhoheit kein KO-Kriterium ist.

5 Praxis-Use-Cases mit messbarem ROI

Aus 23 produktiven mazdek-Multi-Agent-Deployments fuenf reproduzierbare Muster:

1. Treuhand-Pipeline (LangGraph)

Eine Zuercher Treuhand mit 480 KMU-Mandaten setzt LangGraph + Claude 4.7 ein, um 18'000 Eingangsrechnungen pro Monat zu klassifizieren, gegen Bexio zu buchen und Anomalien zu eskalieren. Die 7-Knoten-Pipeline (OCR, Klassifikation, Lieferanten-Match, MWST-Pruefung, Buchung, Anomalie-Detektion, Eskalation) ist mit Postgres-Checkpointer FINMA-pruefbar. Ergebnis nach 6 Monaten: 84% weniger manuelle Verbuchung, 1.2% Anomalie-Eskalations-Rate (vorher 7.4%), CHF 480'000 Einsparung pro Jahr, Payback 4.8 Monate.

2. Versicherungs-Schadenklassifikation (CrewAI)

Eine Schweizer Sachversicherung mit CHF 950 Mio. Praemien orchestriert vier Agenten — Akten-Reader, Schadens-Klassifizierer, Betrugs-Detektor, Kulanz-Empfehler — mit CrewAI. Ergebnis: Schadensdurchlaufzeit -62%, Betrugserkennung 2.1x verbessert, NPS +14 Punkte, Payback 7.2 Monate.

3. Compliance-Review (LangGraph + AutoGen-Hybrid)

Eine Genfer Privatbank kombiniert LangGraph (deterministische Pipeline) mit AutoGen-GroupChat (juristische Diskussion komplexer Faelle). Drei ARES-orchestrierte Compliance-Agenten ueberpruefen FINMA-Rundschreiben gegen interne Prozesse. Ergebnis: 79% schnellere Reviews, 0% FINMA-Bemaengelungen seit Go-Live, CHF 3.1 Mio Jahreseinsparung.

4. Content-Pipeline (CrewAI)

Eine Berner B2B-Marketing-Abteilung produziert mit Researcher, SEO-Spezialist, Writer und Reviewer wochentlich 28 Long-Form-Artikel in vier Sprachen. Ergebnis: Output 4.2x, Time-to-Publish -71%, ranking Top-10 Google fuer 142 neue Keywords, CHF 285'000 Einsparung im Agentur-Budget.

5. DevOps-Incident-Response (LangGraph + MCP)

Ein Basler Fintech setzt einen Multi-Agent-Incident-Responder ein: Detector → Diagnoser → Remediator → Documenter. Ueber MCP greifen die Agenten auf Datadog, GitHub, Kubernetes und PagerDuty zu. Ergebnis: MTTR -68%, P0-Incidents -41% nach 3 Monaten, ARGUS-Reports erfuellen ISO-27001-Audit ohne Beanstandung. Siehe Self-Repairing-AI-Artikel.

Entscheidungs-Matrix: Welches Framework fuer Sie?

Workload-Profil	Empfehlung	Warum
Compliance / FINMA / Audit	LangGraph	Stateful, deterministisch, Postgres-Checkpoint
Content / Marketing / Recherche	CrewAI	Rollen-Metapher passt zu Domaene
R&D / Code-Generierung / Mathe	AutoGen 0.4	GroupChat fuer Diskussion + Selbstkritik
ChatGPT-zentriert / einfache Handoffs	OpenAI Agents SDK	Leichtgewichtig, native API
Microsoft-Stack / .NET-Enterprise	Semantic Kernel	Tiefe Azure-Integration, Plugin-Modell
Type-safe / Pydantic-Welt	Pydantic AI	Schema-Validierung von Anfang an
RAG-zentriert / Index-heavy	llama-index Workflows	Beste Index- und Retrieval-Primitives

Unser PROMETHEUS-Default fuer Schweizer Mid-Market-Enterprise: LangGraph + Claude 4.7 (eskaliert) + DeepSeek-R2 (Standard) + MCP-Tools ueber HERACLES. Diese Kombination liefert in 80% unserer Mandate den optimalen Schnittpunkt aus Kosten, Auditierbarkeit und Geschwindigkeit.

Governance: Multi-Agent-Systeme nach EU AI Act, revDSG und FINMA

Multi-Agent-Systeme werfen vier zusaetzliche Compliance-Fragen auf, die einzelne LLM-Calls nicht hatten:

• EU AI Act Art. 50 (Transparenzpflicht): wenn ein Multi-Agent-System mit Endkunden interagiert, muss erkennbar sein, dass mehrere KI-Agenten beteiligt sind — nicht nur ein einzelner. Best Practice: UI-Hinweis «Dieser Vorgang wird von einem Verbund spezialisierter KI-Agenten bearbeitet.»
• EU AI Act Art. 12 (Protokollierung): jeder Agent-Call, jede Tool-Invocation, jeder Handoff zaehlt zur Eingabe/Ausgabe und muss ueber die gesamte Systemlaufzeit gespeichert werden. Ein 7-Schritt-Workflow erzeugt 7-fach mehr Trace-Volumen als ein Single-Call.
• revDSG Art. 21 (automatisierte Einzelentscheidung): wenn das Multi-Agent-System rechtserhebliche Wirkung hat (Versicherungs-Klassifikation, HR-Entscheid, Kreditrisiko), muss die betroffene Person eine menschliche Ueberpruefung verlangen koennen — und der vollstaendige Multi-Agent-Trace ist Teil der Begruendung.
• FINMA RS 2023/1 (Operationelle Risiken): Multi-Agent-Systeme erzeugen kaskadierende Risiken — ein halluzinierter Agent kann die Pipeline kontaminieren. Pflicht: Eval-Regime, Red-Team-Tests, Cost-Caps und tamper-evident Trace-Archiv ueber 10 Jahre.

Unser EU-AI-Act-Leitfaden enthaelt Multi-Agent-Templates fuer alle vier Punkte. Drei harte Pflichten, die jede Schweizer Multi-Agent-Implementierung erfuellen muss:

1. Trace-Vollstaendigkeit: jeder Agent-State, jeder Tool-Call, jede Handoff-Entscheidung mit OpenTelemetry plus Langfuse erfassen. WORM-Archiv fuer regulierte Mandanten.
2. PII-Redaction zwischen Agenten: sensible Daten duerfen nicht durchgereicht werden, ausser es ist explizit noetig. ARES-Llama-Guard sitzt zwischen Agenten als Bus-Filter.
3. Cost & Loop Caps: harte Token-Limits pro Agent und harte Iteration-Limits (max. 10-15 Loops). Endlosschleifen sind das #1-Risiko in AutoGen-Deployments.

Praxisbeispiel: Treuhand-Pipeline mit LangGraph in 9 Wochen produktiv

Eine Zuercher Treuhand (CHF 14 Mio Umsatz, 62 Mitarbeiter, 480 Mandate) verarbeitet vor 2026 ihre Eingangsrechnungen manuell — 4'200 Mannstunden pro Jahr fuer reines Verbuchen.

Ausgangslage

• 18'000 Eingangsrechnungen/Monat aus PDF, E-Mail-Anhang, QR-Rechnung
• Manuelle Verbuchung in Bexio durch 6 Sachbearbeiterinnen
• Fehlerquote: 4.1% (zumeist falsche MWST-Codes oder Lieferanten-Mismatches)
• Saisonale Spitzen Q1 und Q4 fuehrten zu Rueckstaenden bis 21 Tage

mazdek-Multi-Agent-Loesung in 9 Wochen

Wir bauten eine LangGraph-Pipeline mit sieben Knoten und MCP-Tool-Bus:

• Node 1 (OCR): Mistral-OCR + Tesseract-Fallback, extrahiert strukturierte Felder.
• Node 2 (Klassifikation): PROMETHEUS-Agent mit Claude 4.7 fuer komplexe MWST-Faelle, DeepSeek-R2 fuer Standard.
• Node 3 (Lieferanten-Match): HERACLES mit MCP-Bridge zu Bexio Suppliers + Fuzzy-Matching.
• Node 4 (Verifikation): ORACLE RAG gegen MWST-Recht und Mandanten-Notizen.
• Node 5 (Buchung): Bexio API mit Idempotency-Keys.
• Node 6 (Anomalie): Statistik-Detektor markiert Outlier zur menschlichen Pruefung.
• Node 7 (Eskalation): Slack-/E-Mail-Alert plus Client-Portal-Card.

Ergebnisse nach 6 Monaten Betrieb

Metrik	Vorher	Nachher	Delta
Manueller Aufwand	4'200 h/Jahr	670 h/Jahr	-84%
Verbuchungs-Fehlerquote	4.1%	0.6%	-85%
Anomalie-Eskalations-Rate	7.4%	1.2%	-84%
Durchlaufzeit pro Rechnung	~6 Min	~22 s	-94%
LLM-Kosten pro Rechnung	—	CHF 0.038	—
Jahreseinsparung	—	CHF 480'000	—
Payback	—	4.8 Monate	—

Wichtig: kein Arbeitsplatzabbau. Die sechs Sachbearbeiterinnen wurden zu Anomalie-Spezialistinnen und Mandantenberaterinnen umgewidmet — mit hoeherem Wertschoepfungsbeitrag und besserer Bezahlung. Saisonale Spitzen werden vom System absorbiert, nicht vom Team.

Implementierungs-Roadmap: In 10 Wochen produktiv

Phase 1: Discovery & Framework-Selection (Woche 1-2)

• Workshop: welche Workflows haben heute > 4 Schritte und kosten > 1'000 h/Jahr?
• Framework-Matrix: Determinismus × Audit × Cost × Team-Skill
• Top-2 Workflows auswaehlen, Eval-Set mit 200-500 Faellen aufbauen

Phase 2: PoC mit gewaehltem Framework (Woche 3-5)

• PROMETHEUS baut Graph in LangGraph (oder Crew, AutoGen)
• Eval gegen Gold-Set, Cost-Profile messen
• MCP-Tool-Bridges fuer benoetigte Systeme (Bexio, SAP, Bitrix24, etc.)

Phase 3: Guardrails, Memory & Observability (Woche 6-7)

• ARES implementiert Llama Guard 3 Bus-Filter, PII-Redaction, Loop-Caps
• ORACLE baut Postgres-Checkpointer + pgvector-Episodic-Memory
• ARGUS instrumentiert Langfuse + OpenTelemetry, WORM-Archiv

Phase 4: Infrastruktur & Compliance (Woche 8-9)

• HEPHAESTUS deployed auf Swiss-K8s / Bedrock eu-central-2 Zurich
• EU-AI-Act- und FINMA-Konformitaetspruefung durch ARES
• Red-Team-Tests gegen Prompt-Injection und kaskadierende Halluzinationen

Phase 5: Rollout & Lernen (Woche 10+)

• Shadow-Mode: System laeuft parallel ohne Live-Wirkung
• Supervised: 10% Traffic mit menschlicher Freigabe
• Full-Production: 100% mit Human-in-the-Loop fuer Low-Confidence-Faelle
• Monatliche Eval-Regression, quartalsweise Framework-Upgrades

Die Zukunft: A2A, Council-Modelle und unendliche Schwarme

Multi-Agent-Frameworks 2026 sind erst die zweite Generation. Was 2027-2028 in Sicht steht:

• Agent-to-Agent-Protokoll (A2A): Google, Anthropic und LangChain arbeiten an einem MCP-Pendant fuer Agent-zu-Agent-Kommunikation ueber Vendor-Grenzen hinweg. Ein LangGraph-Agent wird einen CrewAI-Agent direkt aufrufen koennen — ohne Adapter-Code.
• Council-Modelle: Anthropic Council, OpenAI Swarm 2.0 und DeepMind Concurrent zeigen 8-15 Prozentpunkte Accuracy-Gewinn, wenn 3-5 Reasoning-Modelle parallel debattieren und konvergieren. Erste Schweizer Mandate testen das fuer Due-Diligence-Reports.
• Hierarchische Schwaerme: Manager-Agent ueber Manager-Agent ueber Worker. Nutzbar bei Tausenden gleichzeitiger Tasks (Marketing, Support, RPA-Replacement).
• Specialisten-Marketplaces: Cursor Agent Hub, Anthropic Agent Store und HuggingFace Spaces-Agents bringen vortrainierte, signierte Spezialisten — der Vendor-Lock-in der KI-Branche?
• Domain-Fine-Tuned Multi-Agent-Stacks: ein DPO-trainierter Treuhand-Multi-Agent-Stack als Out-of-the-Box-Produkt. mazdek baut den ersten dieser Art fuer Schweizer Treuhand-Branche fuer Q4 2026.
• Long-Horizon-Agenten: Agenten, die Tage und Wochen autonom laufen — Compliance-Sweeps, Marktanalysen, kontinuierliche Tests. Erfordern unendliches Memory (Mem0, Letta) und harte Cost-Governance.

Fazit: Multi-Agent ist die KI-Architektur 2026

• Architektur-Sprung: Single-Agent-LLM-Calls werden 2026 zu Microservices-Aequivalenten — funktional, aber selten optimal. Multi-Agent ist der neue Default fuer Workflows mit mehr als 3 Schritten.
• LangGraph als Schweizer Default: stateful, auditierbar, Postgres-checkpointed. Unsere Empfehlung in 80% der Schweizer Enterprise-Mandate.
• CrewAI fuer rollenbasierte Domaenen: Content, Marketing, Research, juristische Vorgangsbearbeitung.
• AutoGen fuer Reasoning-heavy Workloads: mit Cost-Caps. Ohne Caps wird das Framework zur Kostenfalle.
• OpenAI Agents SDK fuer leichte Handoffs: wenn US-Datenhoheit kein KO-Kriterium ist.
• ROI unter 8 Monaten: 23 produktive mazdek-Mandate, 5.9 Monate durchschnittlicher Payback.
• Compliance ist machbar: EU AI Act, revDSG und FINMA werden mit ARES-Guardrails, ARGUS-Observability und WORM-Archivierung sauber abgebildet — Swiss-sovereign ab Tag eins.

Bei mazdek orchestrieren 19 spezialisierte KI-Agenten den gesamten Multi-Agent-Lebenszyklus: PROMETHEUS fuer Architektur, Routing und Reasoning; HERACLES fuer MCP-Tool-Integration; ORACLE fuer RAG und Memory; ARES fuer Guardrails und Compliance; ARGUS fuer 24/7-Observability und WORM-Audit; HEPHAESTUS fuer Swiss-K8s-Infrastruktur; IRIS fuer Human-in-the-Loop; NANNA fuer Eval-Regression. 23 produktive Multi-Agent-Deployments seit 2024 — DSG-, DSGVO-, EU-AI-Act-, FINMA- und OR-konform ab Tag eins.