Zum Inhalt springen
5.5Experte8 min

Shared Memory vs. Message Passing in Multi-Agent-Systemen

Blck Alpaca·
Definition

Shared Memory und Message Passing sind die zwei Grundparadigmen der Agent-Koordination. Beim Shared Memory (Blackboard-Pattern) lesen und schreiben alle Agenten an einem gemeinsamen Zustand. Beim Message Passing kommunizieren Agenten ausschliesslich über Nachrichten und teilen keinen Zustand. Die Wahl entscheidet über Konsistenz, Kopplung, Skalierung und Debugbarkeit eines Multi-Agent-Systems.

Auf einen Blick

  • Shared Memory (Blackboard) bedeutet einen gemeinsamen Zustand, an dem alle Agenten lesen und schreiben; Message Passing kapselt jeden Agenten und lässt ihn nur über Nachrichten kommunizieren.
  • Die kritische Konsistenzregel lautet: Reads dürfen parallel fan-out laufen, Writes müssen single-threaded bleiben. Concurrent Writes auf geteilten Zustand sind laut Cognition die Todesspirale eines Multi-Agent-Systems.
  • Message Passing dominiert die 2026er-Standards: A2A definiert einen Task-Lifecycle mit opaken Agent-Internas, das OpenAI Agents SDK nutzt Handoffs, das Anthropic Claude Agent SDK den Task-Tool mit komprimierten Rückgaben.
  • Shared Memory ist debugbar bei Single-Writer-Topologien, kollabiert aber bei freien Schreibzugriffen; Message Passing braucht durchgängiges Distributed Tracing mit Correlation-IDs.
  • In der Praxis kombinieren Produktionssysteme beides: interner geteilter Zustand (z. B. LangGraph State-Objekt mit Checkpointing), nach aussen Message Passing über A2A.

Shared Memory und Message Passing sind die zwei Grundparadigmen, mit denen sich mehrere KI-Agenten koordinieren lassen. Beim Shared Memory (in der klassischen Variante das Blackboard-Pattern) lesen und schreiben alle Agenten an einem gemeinsamen Zustand. Beim Message Passing ist jeder Agent gekapselt und kommuniziert ausschliesslich über Nachrichten, ohne geteilten Zustand. Die Entscheidung zwischen beiden bestimmt vier Eigenschaften eines Multi-Agent-Systems: Konsistenz, Kopplung, Skalierung und Debugbarkeit. Dieser Artikel vergleicht die Paradigmen entlang dieser Achsen und zeigt, wann welches passt.

  • Shared Memory / Blackboard: gemeinsamer Zustand (Scratchpad, Vektor-Store, State-Objekt), an dem alle Agenten lesen und schreiben. Stark gekoppelt, einfacher Kontext-Austausch, aber heikel bei parallelen Schreibzugriffen.
  • Message Passing: isolierte Agenten, Austausch nur über Nachrichten. Entkoppelt, skaliert über Prozess- und Anbietergrenzen, ist der Standard hinter A2A, dem OpenAI Agents SDK und dem Anthropic Claude Agent SDK.
  • Die entscheidende Regel: Lesen darf parallel fan-out laufen, Schreiben sollte single-threaded bleiben, unabhängig vom gewählten Paradigma.

Shared Memory und das Blackboard-Pattern

Beim Shared-Memory-Ansatz teilen sich alle Agenten einen zentralen Speicher. Das klassische Blackboard-Pattern stammt aus der KI-Forschung: Ein gemeinsames "Blackboard" hält den aktuellen Stand einer Aufgabe, spezialisierte Agenten beobachten es, lesen die für sie relevanten Teile, tragen ihre Teilergebnisse ein und reagieren auf Änderungen, die andere Agenten verursacht haben. Es gibt keinen festen Ablaufplan; die Reihenfolge ergibt sich daraus, welcher Agent gerade etwas Sinnvolles beitragen kann.

In modernen Multi-Agent-Systemen taucht Shared Memory in mehreren Formen auf. Die Research-Grundlage dieses Artikels nennt als externe Speicherschichten:

  • Vektor-Stores (pgvector, Pinecone, Weaviate, Qdrant) für retrieval-augmentierten Kontext.
  • Strukturierte Datenbanken (Postgres, BigQuery, SAP HANA, Snowflake) für Fakten.
  • Scratchpads als ephemere geteilte Notizblöcke, die Agenten lesen und schreiben, üblicherweise mit Append-only- oder Compare-and-Swap-Semantik.
  • Persistente Agent-Memory (Letta/MemGPT-Stil, LangGraphs Cross-Thread-Store, Anthropics Memory-Tool).

Auch das Peer-to-Peer- bzw. Swarm-Pattern fällt teilweise hierunter: gleichrangige Agenten auf einem geteilten Message-Bus und/oder geteilten Speicher ohne festen Orchestrator. OpenAI Swarm (veröffentlicht Oktober 2024, im März 2025 umbenannt in OpenAI Agents SDK) ist die Referenz. Für DACH-Unternehmenskontexte ist dieses freie Modell allerdings selten geeignet, weil Debugbarkeit und Verantwortlichkeit darunter leiden.

Der wunde Punkt ist Konsistenz. Sobald zwei Agenten denselben Speicher lesen und mindestens einer schreibt, braucht es eine klare Strategie. Die Research-Quelle nennt drei Optionen: (a) optimistische Nebenläufigkeit, (b) ein einzelner Writer mit mehreren Readern oder (c) explizite Lock-Semantik. Die meisten Produktionssysteme wählen (b), das entspricht der Cognition-Regel "Writes stay single-threaded".

Message Passing und Agent-Kommunikation über Nachrichten

Beim Message Passing besitzt jeder Agent seinen eigenen Zustand und sein eigenes Kontextfenster. Informationen fliessen nur über explizite Nachrichten, nie über direkten Zugriff auf fremden Zustand. Das entkoppelt die Agenten: Ein Agent muss nichts über die interne Funktionsweise, das Modell oder den Speicher eines anderen wissen, er muss nur das Nachrichtenformat kennen.

Das ist genau der Designgedanke des Agent-to-Agent-Protokolls (A2A), das im April 2025 von Google bei Cloud Next veröffentlicht und am 23. Juni 2025 an die Linux Foundation übergeben wurde. A2A definiert, wie Agenten reden, nicht wie sie denken: Jeder Agent veröffentlicht eine AgentCard (ein JSON-Dokument mit Endpunkt, Fähigkeiten, Skills, Modalitäten und Auth-Schemata). Eine Zusammenarbeit läuft über einen Task-Lifecycle:

```
submitted -> working -> input-required -> completed | failed | canceled
```

Die internen Abläufe des entfernten Agenten bleiben dabei opak. Genau das erlaubt es, einen Salesforce-Agenten einen SAP-Agenten aufrufen zu lassen, ohne dass einer dem anderen Prompts, Memory oder Modell offenlegt. Während A2A die Agent-zu-Agent-Ebene abdeckt, regelt das Model Context Protocol (MCP) die Agent-zu-Tool-Ebene. Die in der Industrie verbreitete Faustregel (Stand 2026): MCP für Fähigkeiten (Agent zu Tool), A2A für Zusammenarbeit (Agent zu Agent).

Andere Stacks setzen Message Passing mit eigener Semantik um. Die folgende Übersicht stammt direkt aus der Research-Grundlage:

Stack

Message-Passing-Semantik

A2A

Task-Lifecycle, mehrteilige Nachrichten, Artefakte als Output, opake Internas zwischen Agenten

OpenAI Agents SDK

Explizite Handoffs: ein Agent beendet seinen Zug, der nächste übernimmt, Konversationshistorie wird weitergereicht

AutoGen

Group-Chat mit Turn-Taking, geteilte Konversationshistorie, Adressierung über Mentions

LangGraph

Getyptes State-Objekt durch Knoten gereicht, gecheckpointet, durabel über Server-Neustarts

Anthropic Claude Agent SDK

Lead spawnt Sub-Agenten via Task-Tool, Sub-Agenten liefern komprimierte strukturierte Outputs

Bedrock Multi-Agent Collaboration

Supervisor plus Collaborator-Agenten, Routing-Modus vs. volle Orchestrierung

Agentforce

Atlas Reasoning Engine routet, Spezial-Agenten liefern zurück, Konversationskontext erhalten

LangGraph ist hier ein interessanter Grenzfall: Das getypte State-Objekt ist faktisch ein geteilter Zustand, wird aber kontrolliert von Knoten zu Knoten durchgereicht und gecheckpointet, also nicht frei beschrieben. Das ist die in der Praxis übliche Mischform.

Die Tradeoffs im direkten Vergleich

Dimension

Shared Memory / Blackboard

Message Passing

Kopplung

Hoch: alle Agenten kennen das Zustandsschema

Niedrig: nur das Nachrichtenformat ist geteilt

Konsistenz

Heikel: Race Conditions bei Concurrent Writes, braucht Single-Writer oder Locks

Einfacher: kein geteilter Zustand, der korrumpiert werden kann

Skalierung

Begrenzt durch Schreib-Contention auf dem geteilten Speicher

Skaliert über Prozess-, Team- und Vendor-Grenzen

Kontext-Austausch

Sehr direkt: voller Zustand sofort sichtbar

Explizit: nur das, was bewusst gesendet wird

Debugbarkeit

Gut bei Single-Writer, kollabiert bei freien Schreibzugriffen

Braucht Distributed Tracing mit Correlation-IDs über alle Nachrichten

Auditierbarkeit

Zustands-Snapshots, aber "wer hat was entschieden" oft unklar

Jede Nachricht ist ein audit-relevanter Datenpunkt

Typischer Einsatz

Eng gekoppelte Teilaufgaben in einem Prozess

Cross-System-, Cross-Vendor-Workflows

Standard-Protokoll 2026

proprietär / framework-intern

A2A (Linux Foundation), MCP für Tools

Zwei Failure-Modes verdienen besondere Aufmerksamkeit. Erstens Kontextfragmentierung: Sub-Agenten treffen inkompatible implizite Entscheidungen. Cognition.ai formuliert es als Kernkritik: "Scheinbare Meinungsverschiedenheiten zwischen Agenten sind meist Symptome von Kontextfragmentierung." Gegenmittel sind das Teilen voller Traces bei hoher Kopplung, single-threaded Writes und explizite Entscheidungs-Verträge. Zweitens Debuggability Collapse: Bei Message Passing gibt es keinen einzelnen Trace, der den gesamten Lauf abdeckt, sondern N Sub-Agent-Trajektorien plus Synthese. Gegenmittel ist durchgängiges Distributed Tracing mit über jede A2A-Task und jeden MCP-Call propagierten Correlation-IDs.

Konkretes Beispiel: Read-Fan-out mit Single-Writer

Der Anthropic Research Agent (Juni 2025) ist die Referenz für die richtige Aufteilung. Ein Lead-Agent (Claude Opus 4) zerlegt die Anfrage und spawnt N parallele Sub-Agenten (Claude Sonnet 4). Jeder Sub-Agent besitzt sein eigenes rund 200k-Token-Kontextfenster, recherchiert unabhängig und liefert eine komprimierte Zusammenfassung (nicht das volle Transkript) an den Lead zurück, der synthetisiert. Das ist reines Message Passing mit isolierten Kontexten. Ergebnis laut Anthropics internen Evaluierungen (Juni 2025): +90,2 % bei der Recherche-Breite gegenüber einem Single-Agent, allerdings bei rund 15-fachem Token-Verbrauch. Diese Ökonomie rechtfertigt sich nur bei hochwertigen, parallelisierbaren Aufgaben.

Das Gegenstück aus der DACH-Praxis ist Allianz Project Nemo: sieben spezialisierte Agenten (Planner, Cyber, Coverage, Weather, Fraud, Payout, Audit) für Lebensmittelverderb-Schäden nach Naturkatastrophen. Der gesamte Workflow läuft in unter fünf Minuten; ein menschlicher Sachbearbeiter prüft die Audit-Zusammenfassung und trifft die finale Auszahlungsentscheidung (Human-in-the-Loop als explizite Vorgabe). Gestartet in Australien im Juli 2025, deployt in unter 100 Tagen, dokumentiertes Ergebnis: 80 % weniger Bearbeitungs- und Abwicklungszeit für berechtigte Schäden unter AUD 500.

Als Pseudocode formuliert lautet die robuste Topologie:

```

Reads parallelisieren, Writes single-threaden

fragmente = parallel_map(sub_agent.recherchiere, teilaufgaben) # Fan-out, isolierte Kontexte
ergebnis = lead.synthetisiere(fragmente) # genau ein Writer
commit(ergebnis) # single-threaded Write
```

Concurrent Writes mehrerer Agenten auf denselben Zustand sind dagegen laut Research die "Todesspirale" und zu vermeiden.

Wann welches Paradigma

  • Message Passing wählen, wenn Agenten über Prozess-, Team- oder Vendor-Grenzen hinweg zusammenarbeiten, wenn Internas gekapselt bleiben sollen und wenn pro Nachricht auditiert werden muss. Das ist der Default für Cross-System-Workflows (Agentforce zu Joule zu Copilot über A2A) und für read-mostly Fan-out (Recherche, Retrieval, Klassifikation, Review).
  • Shared Memory wählen, wenn eng gekoppelte Teilaufgaben innerhalb eines Prozesses laufen, der gemeinsame Zustand klein und die Schreibfrequenz gering ist, und ein einzelner Writer etabliert werden kann. Das Blackboard eignet sich für Aufgaben ohne festen Ablaufplan.
  • Beides kombinieren, was die Produktionsrealität ist: ein interner LangGraph-Flow mit durablem State-Objekt und Checkpointing, nach aussen als A2A-Endpunkt mit AgentCard exponiert. Intern kontrolliert geteilter Zustand, extern sauberes Message Passing.

Für Agenturen und B2B-Entscheider

Die Paradigmen-Frage ist keine akademische, sondern eine Betriebsrisiko-Frage. Wer im DACH-Raum Multi-Agent-Workflows aufsetzt, sollte als Default Message Passing über die konvergente Standardkombination MCP plus A2A wählen und Shared Memory bewusst auf eng gekoppelte interne Teilaufgaben mit Single-Writer begrenzen. Für Marketing-Agenturen heisst das konkret: Content-, Recherche- und Review-Pipelines profitieren von parallelem Read-Fan-out, der finale Schreibschritt (Veröffentlichung, CRM-Eintrag) bleibt single-threaded. Wer eine produktionsreife, auditierbare Agenten-Architektur für seine Kunden oder das eigene Haus plant, sollte das Coupling-Profil, die Konsistenzstrategie und die Tracing-Infrastruktur früh festlegen, bevor die erste Zeile Orchestrierung entsteht. Genau hier setzt die Beratung von Blck Alpaca an.

Häufig gestellte Fragen

Was ist der Unterschied zwischen Shared Memory und Message Passing bei Agenten?
Bei Shared Memory teilen alle Agenten einen gemeinsamen Zustand (Blackboard, Scratchpad, Vektor-Store), an dem sie lesen und schreiben. Bei Message Passing besitzt jeder Agent einen isolierten Zustand und tauscht Informationen nur über explizite Nachrichten aus. Shared Memory koppelt enger und vereinfacht das Teilen von Kontext; Message Passing entkoppelt, skaliert über Prozess- und Vendor-Grenzen und ist im Multi-Agent-Standard 2026 (A2A, MCP) das vorherrschende Modell.
Was ist das Blackboard-Pattern bei Agenten?
Das Blackboard-Pattern ist eine Shared-Memory-Variante: Ein gemeinsamer Speicher (das Blackboard) hält den Zustand der Aufgabe, mehrere spezialisierte Agenten lesen relevante Teile, tragen ihre Teilergebnisse ein und reagieren auf Änderungen anderer. Es eignet sich für Aufgaben ohne festen Ablaufplan. Der kritische Punkt ist die Schreibkonsistenz: in Produktion meist als Single-Writer mit mehreren Readern oder mit Append-only- bzw. Compare-and-Swap-Semantik umgesetzt.
Wann sollte ich Message Passing statt Shared Memory wählen?
Message Passing ist die richtige Wahl, wenn Agenten über Prozess-, Team- oder Vendor-Grenzen hinweg zusammenarbeiten, wenn Internas (Prompts, Modelle, Speicher) gekapselt bleiben sollen und wenn Auditierbarkeit pro Nachricht gefragt ist. Genau das deckt das A2A-Protokoll ab. Shared Memory lohnt sich eher innerhalb eines Prozesses bei eng gekoppelten Teilaufgaben mit niedriger Schreibfrequenz und einem klaren einzelnen Writer.
Warum sind parallele Schreibzugriffe auf geteilten Zustand problematisch?
Concurrent Writes mehrerer Agenten auf denselben Zustand erzeugen Race Conditions und widersprüchliche implizite Entscheidungen. Cognition.ai bezeichnet das als zentrale Ursache kaskadierender Multi-Agent-Fehler: Scheinbare Meinungsverschiedenheiten zwischen Agenten sind meist Symptome von Kontextfragmentierung. Die Standardlösung lautet: Reads parallelisieren, Writes single-threaded halten, also nur ein Agent oder eine Pipeline-Stufe committet den finalen Zustand.
Welches Paradigma nutzen die gängigen Frameworks 2026?
Stand 2026 setzen die meisten Stacks auf Message Passing mit unterschiedlicher Semantik: A2A nutzt einen Task-Lifecycle mit Artefakten und opaken Internas, das OpenAI Agents SDK explizite Handoffs, AutoGen Group-Chat mit Turn-Taking, das Anthropic Claude Agent SDK den Task-Tool mit komprimierten Rückgaben. LangGraph nutzt ein getyptes, gecheckpointetes State-Objekt zwischen Knoten, ein praktisch geteilter, aber kontrolliert durchgereichter Zustand.

Tiefer einsteigen?

Erhalte neue Analysen direkt ins Postfach – oder sieh dir an, wie wir dieses Wissen für Unternehmen umsetzen.