← Back to Articles
Memory and State Patterns • Part 4

Memory Patterns: Shared Memory and Blackboards

Intent

In multi-agent systems, memory scope becomes a topology decision. Isolated contexts (orchestrator–worker) maximize independence; a shared transcript (conversational pattern) maximizes common ground; a blackboard—a shared artifact store such as a repository or document set through which agents communicate by reading and writing—occupies the middle and revives a classical AI architecture. Artifact-mediated sharing has the advantage that the medium of coordination is also the deliverable, keeping agents grounded in concrete state.

Introduction

In multi-agent engineering, deciding the topology of agent memory is a primary architectural choice. On one hand, isolated contexts (as seen in Orchestrator-Worker designs) protect against context contamination but make lateral knowledge sharing impossible. On the other hand, shared conversational transcripts (Conversational Multi-Agent) maximize common ground but cause immediate context window saturation. The Shared Memory and Blackboards pattern occupies the pragmatic middle: it connects agents via a central, shared repository (the Blackboard) containing files and assets. Agents read and write to this database, making the medium of coordination identical to the project deliverable.

The Blackboard Architecture

A blackboard memory configuration consists of two primary parts:

Central Blackboard Shared Repository codebase_state.json project_requirements.md Agent A e.g., Writer Agent B e.g., Linter Agent C e.g., Compiler

Grounded Coordination via Deliverables

The primary advantage of blackboard memory is that coordination is mediated by deliverables. In chat-based multi-agent systems, agents spend tokens agreeing on plans and formatting files within conversational bubbles. On a blackboard, if Agent A is tasked with drafting code and Agent B is tasked with reviewing it, Agent A writes the file to the shared workspace folder. Agent B reads that file, executes tests, and appends a test report file. Agents are grounded in concrete, files-on-disk state, preventing conversational hallucination.

Trade-offs

Blackboards prevent context dilution but introduce synchronization challenges:

Grounded in Real State

Forces agents to act on actual files and directories rather than abstract conversational traces, reducing goal drift and hallucinations.

Clean Context Windows

Keeps agent-specific transcripts isolated. Agents load only the specific files they need to modify, avoiding history bloat.

Concurrency Conflicts

If multiple agents write to the same files concurrently without lock managers, they override each other's changes, corrupting the repository.

Access Synchronization

Requires complex event-loop orchestrators (e.g. file watchers) to notify successor agents when a blackboard file has been updated.

Known Uses

Blackboard topologies are highly suited for engineering-heavy multi-agent systems:

References