Ein Schwarm von Agenten für die Analyse aus verschiedenen Blickwinkeln: Aufbau eines Expertenteams aus LLMs

Nicht um Geschwindigkeit. Sondern darum, mehrere Agenten mit unterschiedlichen Blickwinkeln über eine einzige Entscheidung diskutieren zu lassen und zu einem Ergebnis zu gelangen, das besser ist als jedes einzelne für sich. Mit vollständigem Code für den Orchestrator, die Experten und die Zusammenführung.

Wenn du ein Modell bittest, eine Entscheidung zu bewerten, erhältst du eine einzige Sichtweise, meistens gemittelt und vorsichtig. Es neigt dazu, zuzustimmen, zu glätten, einen Ausgleich zu finden. Das ist das Problem: Eine wichtige Entscheidung kann nicht von einer einzigen gemittelten Sichtweise bewertet werden, sie muss von verschiedenen Seiten angegangen werden.

Ein Schwarm von Agenten löst das strukturell. Du erstellst mehrere Experten, jeder mit einer festgelegten Rolle und Voreingenommenheit: einer denkt nur an Geld, ein anderer nur an technisches Risiko, ein dritter nur an den Nutzer. Sie analysieren eine Entscheidung unabhängig voneinander, kommen zu unterschiedlichen Schlussfolgerungen, und dann erzwingst du eine Versöhnung dieser Schlussfolgerungen. Der Wert liegt hier nicht in der Geschwindigkeit, sondern darin, dass Uneinigkeit in die Struktur eingebaut ist. Ein einzelner Agent neigt zu Gruppendenken mit sich selbst, ein Schwarm von Rollen nicht.

Dieser Artikel zeigt, wie man einen solchen Schwarm baut, mit Code. Wir behandeln drei Teile: den Orchestrator, der die Rollen vergibt, die Experten, die unabhängig analysieren, und die Zusammenführung, die sie zu einer Schlussfolgerung vereint.

Architektur: Orchestrator, Experten, Zusammenführung

Ein Schwarm zur Analyse besteht aus drei Komponenten.

Der Orchestrator nimmt die Aufgabe und entscheidet, welche Expertenrollen benötigt werden. Bei der Bewertung eines Produktlaunchs könnten das ein Investor, ein Ingenieur, ein Produktspezialist, eine Sicherheitsperson sein. Der Orchestrator analysiert nicht selbst, sondern verteilt die Rollen.

Die Experten arbeiten parallel und unabhängig. Jeder sieht die gleiche Entscheidung, aber durch seine eigene Linse. Entscheidend ist, dass sie die Schlussfolgerungen der anderen nicht sehen, sonst setzt Konformität ein. Unabhängigkeit ist das, was unterschiedliche Blickwinkel hervorbringt.

Die Zusammenführung sammelt die Schlussfolgerungen der Experten und gleicht sie ab: wo sie übereinstimmen, wo sie sich widersprechen, was das endgültige Urteil aus allen Blickwinkeln ist. Dabei geht es nicht um eine Mittelung, sondern um eine Synthese, die Uneinigkeit als Signal bewahrt.

Schritt 1: Der einfache Client

Beginne mit einem einfachen Client für das Modell. Ich verwende ein OpenAI-kompatibles Nachrichtenformat, das mit den meisten Anbietern und lokalem Ollama funktioniert.

1import requests
2import json
3from concurrent.futures import ThreadPoolExecutor
4
5API = "http://localhost:11434/api/chat"   # Ollama, oder ein Provider-Endpunkt
6MODEL = "qwen2.5:32b"
7
8def ask(system, user, temperature=0.7):
9    resp = requests.post(API, json={
10        "model": MODEL,
11        "messages": [
12            {"role": "system", "content": system},
13            {"role": "user", "content": user},
14        ],
15        "temperature": temperature,
16        "stream": False,
17    }, timeout=120)
18    resp.raise_for_status()
19    return resp.json()["message"]["content"]

Schritt 2: Der Orchestrator vergibt Rollen

Der Orchestrator erhält die Aufgabe und entscheidet, welche Experten benötigt werden. Hardcode die Rollen nicht im Voraus, lass das Modell sie für die spezifische Aufgabe auswählen – das macht den Schwarm universell. Fordere striktes JSON zum Parsen.

1ORCHESTRATOR_SYSTEM = """Du bist der Orchestrator eines analytischen Schwarms.
2Definiere für die Aufgabe 3-5 Expertenrollen, die maximal UNTERSCHIEDLICHE
3und widersprüchliche Ansichten zur Entscheidung liefern. Die Rollen müssen
4sich in ihren Interessen widersprechen, nicht ergänzen.
5
6Gib für jede Rolle: Name (name), Fokus (focus) – worauf sie fixiert ist,
7Bias (bias) – wozu sie neigt, was sie tendenziell überschätzt.
8
9Antworte NUR mit einem JSON-Array, keine Erklärungen:
10[{"name": "...", "focus": "...", "bias": "..."}, ...]
11"""
12
13def plan_roles(task):
14    raw = ask(ORCHESTRATOR_SYSTEM, f"Zu analysierende Aufgabe:\n{task}",
15              temperature=0.9)   # höhere Temperatur für Rollenvielfalt
16    # JSON herausschneiden, falls das Modell Text drum herum hinzugefügt hat
17    start, end = raw.find("["), raw.rfind("]") + 1
18    return json.loads(raw[start:end])

Wir halten die Temperatur hier bewusst hoch: wir wollen vielfältige, nicht offensichtliche Rollen. Die Anforderung "die Rollen müssen sich widersprechen" im Prompt ist der Schlüssel; ohne sie liefert das Modell drei nahezu identische Rollen und der ganze Sinn des Schwarms geht verloren.

Schritt 3: Die Experten analysieren parallel und unabhängig

Jeder Experte erhält seine Rolle und dieselbe Entscheidung. Entscheidend: sie laufen parallel und sehen die Schlussfolgerungen der anderen nicht. Parallelität dient hier nicht nur der Geschwindigkeit, sie garantiert Unabhängigkeit – ein Experte kann sich physisch nicht an die Meinung eines anderen anpassen.

1EXPERT_SYSTEM = """Du bist ein Experte mit der Rolle: {name}.
2Dein Fokus: {focus}.
3Dein Bias: {bias}. Kämpfe nicht dagegen an, es ist dein Wert für die Analyse.
4
5Analysiere die Entscheidung STRIKT aus deiner Position. Sei nicht ausgewogen,
6versuche nicht, andere Standpunkte zu berücksichtigen – das machen andere Experten.
7Deine Aufgabe ist es, deinen Blickwinkel bis zum Äußersten zu vertreten.
8
9Gib:
10- ein Urteil aus deiner Position (dafür / dagegen / bedingt)
11- 2-3 Hauptargumente speziell aus deinem Blickwinkel
12- 1 Risiko, das aus deiner Position am deutlichsten sichtbar ist und andere übersehen werden
13Kurz und hart, kein Blabla."""
14
15def run_expert(role, task):
16    system = EXPERT_SYSTEM.format(**role)
17    opinion = ask(system, f"Zu analysierende Entscheidung:\n{task}", temperature=0.7)
18    return {"role": role["name"], "opinion": opinion}
19
20def run_swarm(roles, task):
21    # paralleler Start: Unabhängigkeit plus Geschwindigkeit
22    with ThreadPoolExecutor(max_workers=len(roles)) as pool:
23        futures = [pool.submit(run_expert, role, task) for role in roles]
24        return [f.result() for f in futures]

Beachte den Prompt des Experten: wir verbieten ihm explizit, ausgewogen zu sein. Das ist kontraintuitiv, aber genau das ist der springende Punkt. Wenn jeder Experte versucht, alle Seiten zu berücksichtigen, bekommst du fünf identische vorsichtige Meinungen. Indem wir jeden zwingen, seinen Blickwinkel bis zum Äußersten zu vertreten, erhältst du ein echtes Spektrum, das die Zusammenführung dann zusammenführt.

Schritt 4: Die Zusammenführung führt die Schlussfolgerungen zusammen

Jetzt haben wir mehrere scharfe, einseitige Meinungen. Die Zusammenführung fasst sie zu einem Urteil zusammen, aber nicht durch Mittelung. Sie sucht nach Übereinstimmungen der Experten (ein starkes Signal), nach Widersprüchen (eine Risikozone, die eine Entscheidung erfordert) und danach, was was überwiegt.

1MERGE_SYSTEM = """Du bist der Synthesizer eines analytischen Schwarms. Du
2erhältst die Meinungen mehrerer Experten mit unterschiedlichen Vorurteilen zu
3einer Entscheidung.
4
5Deine Aufgabe ist NICHT, sie zu mitteln. Deine Aufgabe ist:
61. Übereinstimmung: Worin waren sich die Experten trotz unterschiedlicher
7   Positionen einig. Das ist das zuverlässigste Signal, hebe es hervor.
82. Konflikt: Wo die Experten sich direkt widersprechen. Glätte nichts,
9   benenne den Konflikt explizit und sage, was jede Seite kostet.
103. Blindstellen: Ein Risiko, das nur ein Experte genannt hat, das aber wichtig ist.
114. Endgültiges Urteil über alles: dafür / dagegen / bedingt, und unter welchen
12   Bedingungen es sich ändert.
13
14Schreibe dicht. Behalte Uneinigkeit als Information, verstecke sie nicht."""
15
16def merge_opinions(task, opinions):
17    block = "\n\n".join(
18        f"### Experte: {o['role']}\n{o['opinion']}" for o in opinions
19    )
20    user = f"Entscheidung:\n{task}\n\nExpertenmeinungen:\n{block}"
21    return ask(MERGE_SYSTEM, user, temperature=0.4)   # niedrigere Temperatur für nüchterne Synthese

Wir senken die Temperatur bei der Zusammenführung: wenn die Experten vielfältig sein sollen (hohes T), sollte der Synthesizer nüchtern und konsistent sein (niedriges T). Die Schlüsselanweisung hier ist "nicht mitteln, Uneinigkeit als Information behalten". Eine normale Zusammenführung kollabiert alles zu Brei: "einerseits, andererseits." Eine gute Zusammenführung sagt klar: hier sind sich alle einig, und hier gibt es einen Konflikt, der so viel kostet.

Schritt 4.5: Ein Advocatus Diaboli gegen falsche Übereinstimmung

Es gibt eine leise Gefahr: Manchmal sind sich die Experten nicht einig, weil die Entscheidung gut ist, sondern weil alle aus Trägheit in die gleiche Richtung schauen. Das ist eine falsche Übereinstimmung, und sie ist gefährlicher als offener Konflikt, weil sie wie Selbstvertrauen aussieht.

Dagegen fügen wir einen speziellen Agenten hinzu, den Advocatus Diaboli. Seine einzige Aufgabe ist es, den Konsens anzugreifen. Er sieht alle Meinungen der Experten und ist verpflichtet, herauszufinden, warum sie alle gleichzeitig falsch liegen könnten. Wenn der Schwarm einstimmig "dafür" gestimmt hat, sucht der Advocatus nach einem Szenario, in dem es eine Katastrophe ist.

1DEVIL_SYSTEM = """Du bist der Advocatus Diaboli in einem analytischen Schwarm. Du
2bekommst die Meinungen der Experten. Deine einzige Aufgabe: greife ihre Übereinstimmung an.
3
4Wenn die Experten sich auf etwas geeinigt haben, finde heraus, warum sie ALLE GLEICHZEITIG
5falsch liegen könnten. Suche nach einer gemeinsamen Blindstelle: einer Annahme, die alle
6ohne Überprüfung akzeptiert haben, einem Szenario, das niemand in Betracht gezogen hat,
7weil es unbequem ist.
8
9Sei nicht höflich. Dein Wert liegt darin, dass du sagst, was die Gruppe nicht hören will.
10Gib:
11- welche gemeinsame Annahme der Experten am gefährlichsten ist
12- ein Szenario, in dem sich die einhellige Meinung des Schwarms als fatal falsch erweist
13- eine Frage, die die Gruppe sorgfältig vermieden hat
14Wenn es keine Übereinstimmung gibt und die Experten sich wirklich uneinig sind, sag das
15klar und weise auf den schärfsten ungelösten Konflikt hin."""
16
17def run_devil(task, opinions):
18    block = "\n\n".join(
19        f"### {o['role']}\n{o['opinion']}" for o in opinions
20    )
21    user = f"Entscheidung:\n{task}\n\nSchwarmmeinungen:\n{block}"
22    return ask(DEVIL_SYSTEM, user, temperature=0.8)

Der Advocatus läuft nach den Experten, aber vor der Zusammenführung, und sein Angriff fließt zusammen mit den Meinungen in die Synthese ein. Der Punkt ist, dass selbst ein einstimmiger Schwarm mindestens einen Agenten hat, der verpflichtet ist, nach einem Riss zu suchen. Das ist billig (ein Aufruf) und bricht strukturell das Gruppendenken: Der Konsens muss jetzt einen Angriff überstehen, nicht nur zufällig entstehen.

Schritt 4.6: Eine Debattenrunde, um den Konflikt zu schärfen

Der erste Expertendurchlauf ist unabhängig, und das ist richtig für die Vielfalt. Aber nachdem die Meinungen gesammelt sind, kannst du eine Debattenrunde einlegen: Zeige jedem Experten eine Zusammenfassung der Meinungen der anderen und lass ihn Einwände erheben. Das schärft die Konflikte, schwache Argumente fallen weg, starke werden gefestigt.

1DEBATE_SYSTEM = """Du bist Experte {name} in der zweiten Runde der Analyse.
2Deine ursprüngliche Position:
3{own_opinion}
4
5Jetzt siehst du die Meinungen der anderen Experten. Gib nicht unter Druck nach,
6aber ignoriere auch keine starken Argumente. Gib:
7- wo ein Argument eines anderen deine Position wirklich trifft, gib das ehrlich zu
8- wo du deine Linie hältst und warum sein Einwand schwach ist
9- ob du dein Urteil nach der Debatte geändert hast, und wenn ja, wie
10Kurz. Dies ist keine Wiederholung der ersten Meinung, sondern eine Reaktion auf Gegner."""
11
12def debate_round(roles, task, opinions):
13    others_map = {}
14    for o in opinions:
15        others = "\n\n".join(
16            f"### {x['role']}\n{x['opinion']}" for x in opinions if x is not o
17        )
18        others_map[o["role"]] = others
19
20    def rebut(o):
21        system = DEBATE_SYSTEM.format(name=o["role"], own_opinion=o["opinion"])
22        user = (f"Entscheidung:\n{task}\n\n"
23                f"Meinungen der Gegner:\n{others_map[o['role']]}")
24        return {"role": o["role"], "opinion": ask(system, user, temperature=0.6)}
25
26    with ThreadPoolExecutor(max_workers=len(opinions)) as pool:
27        return list(pool.map(rebut, opinions))

Die Debattenrunde ist ebenfalls parallel: Jeder Experte reagiert gleichzeitig auf alle anderen, wieder ohne zeitgleiche Konformität. Nach der Debatte sind die Meinungen meist schärfer: Du siehst, welche Positionen unter Beschuss standgehalten haben und welche zusammengebrochen sind. Diese gehärteten Meinungen gehen in die endgültige Zusammenführung ein.

Schritt 5: Alles zusammenfügen

1def analyze(task, debate=True):
2    print("Orchestrator wählt Rollen aus...")
3    roles = plan_roles(task)
4    for r in roles:
5        print(f"  - {r['name']}: {r['focus']}")
6
7    print(f"\nStarten von {len(roles)} Experten parallel...")
8    opinions = run_swarm(roles, task)
9    for o in opinions:
10        print(f"\n[{o['role']}]\n{o['opinion']}")
11
12    # optionale Debattenrunde: Experten reagieren aufeinander
13    if debate:
14        print("\nDebattenrunde: Experten widersprechen sich gegenseitig...")
15        opinions = debate_round(roles, task, opinions)
16
17    # Advocatus Diaboli greift die Übereinstimmung des Schwarms an
18    print("\nAdvocatus Diaboli sucht nach einem Riss in der Übereinstimmung...")
19    devil = run_devil(task, opinions)
20    print(f"\n[Advocatus Diaboli]\n{devil}")
21
22    # Zusammenführung führt die Schlussfolgerungen plus den Angriff des Advocatus zusammen
23    print("\nZusammenführung gleicht die Schlussfolgerungen ab...")
24    opinions_plus = opinions + [{"role": "Advocatus Diaboli", "opinion": devil}]
25    verdict = merge_opinions(task, opinions_plus)
26    print(f"\n=== ENDGÜLTIGES URTEIL ===\n{verdict}")
27    return verdict
28
29if __name__ == "__main__":
30    analyze(
31        "Wir möchten die kostenlose Stufe abschaffen und das Produkt vollständig "
32        "kostenpflichtig mit einer 14-tägigen Testversion machen. Sollten wir das tun?"
33    )

Wenn du das ausführst, siehst du die gesamte Pipeline: Der Orchestrator wählt Rollen aus, die Experten schneiden die Wahrheit aus ihren Blickwinkeln zurecht, streiten sich in der Debattenrunde, der Advocatus greift ihre Übereinstimmung an, und die Zusammenführung liefert ein Urteil über alles, einschließlich des Angriffs. Ein einzelner Agent würde auf dieselbe Frage eine vage „es kommt auf dein Publikum an“-Antwort geben, der Schwarm liefert eine strukturierte Aufschlüsselung, bei der die Konflikte explizit und der Konsens einem Stresstest unterzogen sind.

Was diesen Schwarm zum Funktionieren bringt

Drei Dinge unterscheiden einen nützlichen Schwarm von einem Theater aus Agenten.

Rollen müssen sich widersprechen, nicht ergänzen. Wenn deine Experten „ein Marketer, ein SMM-Spezialist, ein Content Manager“ sind, werden sie nahezu identische Antworten geben, weil ihre Interessen übereinstimmen. Der wahre Wert entsteht, wenn die Interessen in Konflikt geraten: Wachstum vs. Nachhaltigkeit, Geschwindigkeit vs. Qualität, Geld jetzt vs. Vertrauen später. Ein Interessenkonflikt ist es, der die Entscheidung aufbricht.

Experten dürfen sich nicht sehen. Sobald ein Experte die Meinung eines anderen sieht, beginnt die Konformität, er passt sich an. Unabhängigkeit ist kein Implementierungsdetail, sondern eine Arbeitsbedingung. Der parallele Start liefert sie kostenlos.

Die Zusammenführung mittelt nicht, sie bewahrt den Konflikt. Eine schlechte Synthese verwandelt fünf scharfe Meinungen in eine einzige zahnlose Zusammenfassung. Eine gute Synthese lässt den Konflikt sichtbar, denn der Konflikt ist die wertvollste Information: Er zeigt, wo die Entscheidung wirklich riskant ist, nicht wo alle nicken.

Wo man erweitern kann

Dieses Grundgerüst lässt sich in offensichtliche Richtungen erweitern. Du kannst eine Debattenrunde hinzufügen: Zeige den Experten nach der ersten Zusammenführung die Zusammenfassung und lass sie Einwände erheben, das schärft die Konflikte. Du kannst einen Richter mit einem stärkeren Modell über die Experten setzen, um die Argumente abzuwägen. Du kannst die Rollen für eine wiederkehrende Art von Entscheidung dauerhaft machen, sodass du sie nicht jedes Mal neu generieren musst.

Aber das Grundprinzip bleibt: unterschiedliche Linsen, unabhängige Analyse, eine Synthese, die Uneinigkeit respektiert. Ein Schwarm ist für die Analyse nützlich, nicht weil es viele Agenten gibt, sondern weil sie unterschiedlich schauen und sich nicht gegenseitig in einen gemeinsamen Nenner abgleiten lassen. Nimm eine Entscheidung, die du gerade allein im Kopf wälzt, und lass sie durch einen solchen Schwarm laufen. Du wirst Blickwinkel sehen, die du nicht hattest.