Blackboard
Also known as: blackboard architecture, shared workspace, shared state coordination, task board, tuple space, stigmergy (when the shared medium is an environment)
Intent
Specialist agents never talk to each other. They read from and write to one shared, structured workspace, and a control component (or the agents themselves) looks at what the workspace contains to decide who contributes next. The solution builds up from accumulated entries, not from a fixed sequence or a conversation.
Problem
A data team builds an assistant over an observatory data lake of about 1,500 files: observation logs, instrument telemetry and calibration notes. An analyst asks: "Which 2019 observations had the highest noise, and how does noise relate to instrument temperature?" No single agent can read every file, so the team gives each cluster of files to its own file agent. This scenario is adapted from the data-discovery setting studied by Salemi et al. (Google Cloud AI Research and UMass Amherst).
The first version puts a supervisor in front of the file agents. It splits the question, decides which agent should answer each part, and relays every result. It breaks in ways that get worse as the lake grows:
- The supervisor has to know what every helper holds. It sends the temperature question to the observation-log agent because nothing told it that temperature lives in the telemetry files. Salemi et al. argue that at scale the main agent simply does not have this visibility.
- The useful order is not known in advance. A file agent finds that timestamps in the telemetry are local time, not UTC. That should change the next request, but a fixed plan or pipeline has already decided what comes next.
- Everything goes through one context. Every partial result is relayed through the supervisor, which costs its context window and tokens.
- Partial results get lost. In a chat-style log, the noise table from turn 37 is hard to find again. Nothing addresses it by type or id.
Solution
Put the problem state in a shared, structured store: the blackboard. It has sections (requests, evidence, hypotheses, critiques, decisions, solution) and typed entries with an id, an author, a status and links to the entries that support them. Specialists read the part of the board they care about and write new entries. A control component looks at the board after each round and picks who acts next, so the order follows from what is on the board instead of from a plan written in advance.
- Seed. The harness writes the analyst's question to the board, plus the decisions every writer must respect: times in UTC, noise measured as background RMS.
- Pick and act. The control unit sees no evidence yet and selects the analyst agent, which posts two requests without naming a recipient: "noise per 2019 observation" and "temperature time series for 2019". Next round the controller selects both file agents. Each writes evidence entries with file paths and a small sample.
- React to what appeared. The telemetry agent's evidence notes that its timestamps are local time. The analyst joins the evidence, converts the times, and writes hypothesis
hyp-0012("noise peaks in March 2019 runs on instrument B") withsupportslinks to the evidence ids. - Review. The controller sees an unreviewed hypothesis and selects the critic. It writes a critique naming
hyp-0012: two runs are missing from the join. The analyst writes a new version that supersedes the old one. - Clean up and stop. A cleaner removes superseded entries from what agents see. The decider finds an accepted hypothesis with no open critique, writes the solution section, and the run ends.
Who decides the flow is split three ways. The content of the board decides what is possible, the control component decides what happens next, and each agent decides what to write. Nobody fixes the global order in advance. That is the difference from a Supervisor, which must know every worker's competence and relays all information, and from a Group Chat, where the shared medium is a transcript ordered by time that every agent reads in full. A blackboard is organised by content: entries can be updated, superseded or removed, and an agent reads only its part.
Real-world analogy
A team of detectives works a case around a wall of evidence. Nobody hands out assignments one by one. When the fingerprint specialist pins up a match, the person who knows the suspect's movements sees it and adds a timeline next to it. The lead looks at the wall and says who should look at what next. The wall is the blackboard, each specialist is a knowledge source, and the lead's glance at the wall is the control component.
The analogy stops working on concurrency. Detectives in one room see each other reach for the same photo. Agents running in parallel do not, so the board needs explicit claims, versions or ownership rules to stop two of them overwriting each other.
Structure
- Blackboard. The shared store: task, decisions, open requests, evidence, hypotheses, critiques and the final solution. Every entry has an id, a type, an author, a status (proposed, accepted, rejected, superseded) and links to what supports it. The schema is the contract between agents and the most important design decision.
- Control unit. Reads the board each round and selects the smallest useful set of agents. It can be an LLM (bMAS), rules or subscriptions on entry types (MetaGPT), or absent, with agents volunteering or claiming work themselves.
- Specialists (knowledge sources). Each has a narrow expertise, a condition for when it is relevant, and an entry type it writes. Here: one file agent per data cluster, a web-search agent, an analyst that runs code, and a critic. They never call each other.
- Housekeeping. A cleaner removes redundant and superseded entries from what agents see, and a conflict resolver gets contradictory entries reconciled. Without it the board grows every round.
- Decider. Judges whether the board holds a good enough answer and writes the solution section. Code checks (round caps, a goal predicate such as "all tests pass") back it up.
Prompt generator
Describe the task, the board sections and each specialist's contract (what it reads, when it is relevant, what it writes). The generator gives you a board entry format, a control prompt (an LLM control unit, or a requester that posts to the board for volunteers), a specialist prompt to fill per agent, and a decider prompt. Use them in a graph framework where a router node reads shared state, or in your own loop around a store.
Generated prompt
Highlighted text comes from the form. [Bracketed] text is still to fill in.
Rendering the whole board into every agent's prompt is the main token cost of the pattern. Give each agent a view with the task, the decisions and only the sections and statuses it needs. In the bMAS ablation, merely marking redundant entries instead of removing them from the prompt lowered accuracy: what agents see counts more than what is stored.
Applicability
Use it when
- The order of useful contributions cannot be fixed in advance. This is the original motivation for blackboard systems: whoever can make progress now should act.
- There are many specialists, possibly unknown to the requester. A request posted to the board reaches whoever can help, and adding a specialist does not change the requester or the other agents.
- Knowledge or data is partitioned and large. In Salemi et al.'s data-discovery study, the blackboard's advantage over a master–slave design grew with the size of the data lake.
- The shared state must outlive any one context window. A codebase or document set that survives agent crashes and new sessions is a natural board.
- Many agents should work in parallel and the work splits into disjoint claims. Self-claiming from a task board avoids a central bottleneck.
- You need an inspectable record of partial results and who produced them. Typed, attributed entries are easier to audit than a chat transcript.
Avoid it when
- The task is short and the steps are known. Prompt Chaining or Plan-and-Execute is simpler and cheaper.
- One manager can route everything cheaply. With few workers and clear capabilities, a Supervisor or Orchestrator–Workers is easier to debug.
- The work is write-heavy on one artifact. Parallel writers to the same files produce conflicts and inconsistent implicit decisions. Cognition still recommended single-threaded writes in its April 2026 follow-up; keep one writer.
- You have one model and modest tasks. bMAS run with a single Llama model scored below plain chain-of-thought on MATH (58.4 against 62.2, from the bMAS paper).
- Latency per request must be minimal. Rounds of selection, contribution and cleanup add serial steps.
- Agents must not see each other's data. Unless you build per-entry access control, a shared board shares everything.
How to implement
- Check that you need it. Choose a blackboard when contributions are opportunistic, specialists are many or unknown in advance, or the problem state is too big to live in one context window. Otherwise use a chain, a plan or a supervisor.
- Design the schema. Sections, entry types, statuses, required fields and who may write where. Keep
contentas natural language but makeid,author,status,supportsandsupersedesmachine fields, and add adecisionssection that every writer must respect. - Pick a store with the concurrency you need. In-process state for a single run, a database or key-value store with versions for concurrent agents, git when the shared state is code. Prefer JSON over free Markdown for structured lists: Anthropic found the model less likely to rewrite JSON inappropriately.
- Write each agent's contract. What it reads (sections and filters), when it is relevant, what entry type it writes, and what it must never touch. If it disagrees with an entry, it writes a critique naming the id instead of editing it.
- Choose the control scheme. An LLM control unit, rule-based subscriptions on entry types, volunteers that decide their own relevance, or self-claiming with locks. Make sure the controller sees open claims.
- Handle write conflicts. Give each writer its own keys, use reducers that merge concurrent updates, use compare-and-set on a version number, or partition ownership. Claims need an owner, a timestamp and an expiry so a janitor can reclaim them after a crash.
- Add housekeeping. Conflict detection, superseding, removal of redundant entries, and compaction of old rounds into one summary entry.
- Define termination and hard budgets. Combine a decider, a goal predicate, quiescence (nothing triggered for a round), round and token caps, and a stall counter (rounds without a new accepted entry).
- Log every write as an event. Record timestamp, agent, operation, entry id, versions before and after, and every control decision with its reason, so you can replay how the board evolved.
Few frameworks ship something named "blackboard". Most offer shared state that becomes one only when something reads its contents to decide who acts next.
| Framework | Shared store | Where the control comes from |
|---|---|---|
| LangGraph | Typed StateGraph state; reducers such as Annotated[list, operator.add] merge parallel writes. Without a reducer, later writes overwrite, and two parallel writes in one superstep raise INVALID_CONCURRENT_GRAPH_UPDATE. | A router node that reads the state and returns Command(goto=...), or conditional edges |
| Google ADK | Session state; output_key saves an agent's reply, {key} reads it in another agent's instruction. Prefixes user:, app:, temp: set the scope. | A coordinator or custom agent that reads state and picks a sub-agent |
| MetaGPT | A shared message pool; roles publish structured documents and subscribe to the types they need | Subscriptions, inside a largely fixed SOP order |
| Claude Code agent teams | A shared task list (pending, in progress, completed, with dependencies) plus per-agent mailboxes | The lead assigns, or teammates self-claim with file locking |
| Letta | Memory blocks attached to several agents; concurrent writes: last write wins | Your own code |
| CrewAI | One unified Memory shared by the crew when memory=True | The crew process (sequential or hierarchical), so shared memory rather than a controlled board |
| AWS Strands | Shared context passed along a Swarm: task, agent history, contributed knowledge | Handoffs, so a light board inside a Swarm |
| Plain files and git | A repo with code, notes, progress files and lock files | Agents claim tasks themselves |
Caveat. Claude Code agent teams are experimental and off by default, and their claiming mechanics may change. CrewAI replaced its separate short-term, long-term and entity memories with one Memory class, so older tutorials are out of date. Expect other details in this table to drift.
Variants
Classic blackboard
Hearsay-II, a 1970s speech-understanding system, organised the board in levels of abstraction from sound segments up to phrases, with hypotheses at one level linked to supporting ones below. A scheduler rated triggered knowledge sources and ran the best one. BB1 went further and put control decisions on a separate control blackboard, so the system could reason about its own strategy. (The Hearsay-II level names come from secondary summaries; the original paper was not read directly.)
LLM control unit
bMAS (Han and Zhang, 2025) uses the board as the only channel, with a public space and private spaces for small debates. Predefined planner, critic, decider, conflict-resolver and cleaner roles work next to experts generated per question, and an LLM picks who acts each round, up to 4 rounds. If the cap is hit without a decision, every agent answers from the board and the answer most similar to the others wins.
Request board with volunteers
In Salemi et al.'s system, a main agent running a ReAct loop posts help requests without naming a recipient. Every helper decides whether its files are relevant, and replies go to a private response board for that request, so helpers do not influence each other. The requester treats the replies as the observation of its "request help" action. No one needs a map of who knows what.
Self-claiming task board
No scheduler at all. In Anthropic's C compiler experiment, each agent synced a shared git repo, picked the next obvious task, claimed it by writing a file in current_tasks/, and released it after merging. A rejected push meant another agent had won the race. Claude Code agent teams use a shared task list the same way.
Publish–subscribe pool
Agents declare which entry types they care about and are triggered when one appears. MetaGPT works this way, though its order is still mostly set by a standard operating procedure. No LLM is needed in the control loop.
Light blackboards: shared state and session keys
LangGraph state, ADK session keys and Letta shared memory blocks are stores. They become a blackboard only when a router reads their contents to choose the next agent. When the order comes from fixed edges, you have a pipeline that shares variables.
Stigmergy and tuple spaces
Stigmergy is coordination through traces left in a shared environment, like ant pheromone trails that evaporate over time. Evaporation maps to expiry of low-value entries. Linda's tuple space offers a minimal board API: out writes a tuple, in takes a matching one, rd reads without removing. A destructive in is an atomic claim, which is what lock files imitate. Framework "swarms" mean handoffs, a different mechanism covered in Swarm / Handoffs.
Pros and cons
Pros
- The requester does not need to know who can help. Adding a specialist touches no other agent.
- Order follows the problem: an agent acts when something it can improve appears.
- Partial results are addressable by section and id, with author and provenance, instead of being buried in a transcript.
- Agents are decoupled in time and space: a reader can come later, even in another session or process.
- In data discovery, Salemi et al. report 13 to 57% relative improvement in end-to-end success over the best baseline (a master–slave design), at similar wall-clock time (132 to 145 seconds across systems).
- Distributed variants have no central single point of failure. Anthropic's vendor-published compiler run had 16 agents coordinate only through a git repo and lock files.
Cons
- Token cost: the board is rendered into many prompts. Salemi et al. measured about 1.8 times the cost of master–slave per question.
- Gains on reasoning benchmarks are small: bMAS led ChatEval by about 1.1 points on average (81.68 against 80.56), within noise on test sets as small as 198 questions, and its code was not released.
- Concurrent writers need reducers, versions or locks, and locks do not stop semantic conflicts.
- Emergent order is harder to predict, test and bound than a fixed pipeline.
- The shared schema is a dependency for every agent; changing it touches all of them.
- No natural last step: termination has to be designed.
Failure modes
- Board bloat
-
Prompts grow every round, cost rises and agents lose focus.
Mitigation: a cleaner that removes redundant entries from the view, per-agent views, old rounds compacted into one summary entry, and expiry on low-value entries.
- Lost updates
-
Two agents update the same entry and one change silently disappears.
Mitigation: reducers, compare-and-set on a per-entry version, an append-only log with a computed view, or one owner per region.
- Duplicate work and hot spots
-
Several agents solve the same sub-problem. In the compiler run, once tests nearly passed, every agent converged on the same failing Linux kernel build and overwrote each other's fixes.
Mitigation: claims with leases that the controller can see. Above all, partition the work so claims are naturally disjoint: the fix there was to compile most kernel files with GCC as a reference and only a subset with the new compiler, so agents hit different bugs.
- Stale claims
-
A crashed agent leaves a claim forever. One compiler agent ran
pkill -9 bashand ended its own loop.Mitigation: owner, timestamp and expiry in every claim, and a janitor that reclaims old ones.
- Contradictions and conflicting implicit decisions
-
The board holds incompatible hypotheses, or pieces written by different agents do not fit (units, interfaces, style). The final answer picks one arbitrarily.
Mitigation: explicit
statusandsupersedesfields, a conflict resolver (bMAS sends the two authors to a private space to settle it), a decisions section every writer reads, and a single final writer. - Hallucinated entries propagate
-
One agent writes a false fact and others build on it.
Mitigation: require
supportslinks to evidence, run a critic, and use tests or other checkers as ground truth where they exist. - Herding
-
Agents copy the most visible entry instead of thinking independently.
Mitigation: private response boards so helpers do not see each other's replies, and independent first drafts.
- No termination
-
Agents keep adding marginal entries.
Mitigation: a decider, a goal predicate, quiescence detection, round and token caps, and a stall counter.
- Controller never picks the right agent
-
A specialist is never selected, so its data never reaches the board.
Mitigation: clear role descriptions, let agents self-nominate, and audit "never selected" in the logs.
- Prompt injection through the board
-
Text copied from a web page or file by one agent is read as an instruction by another.
Mitigation: treat entries as data, mark entries that carry external content, and restrict which entry types can trigger actions.
- Schema drift
-
Agents invent fields or rewrite the structure.
Mitigation: validate every write against the schema and keep structured lists in JSON.
Relations with other patterns
- Group Chat: the closest neighbour. A shared conversation ordered by time that every agent reads in full, against a workspace organised by content that each agent reads selectively.
- Supervisor: the supervisor is a message hub that must know every worker's competence. In a blackboard the store is the hub and the controller only selects, or agents select themselves.
- Orchestrator–Workers: workers report through the orchestrator. An artifact store where workers write and pass references back is a light blackboard; Magentic-One's ledgers are a workspace that only the orchestrator writes.
- Swarm / Handoffs: often confused because of the word. Framework swarms pass control with handoff tools; "swarm intelligence" (stigmergy) is indirect coordination through shared state and belongs here.
- Council / Debate: debaters answer the same question, while blackboard agents contribute different expertise to one solution. bMAS runs small debates inside private spaces of its board.
- Parallelization: parallel branches writing distinct keys or merging through reducers form a light blackboard. A full blackboard adds agents that react to each other's writes.
- Plan-and-Execute: a persisted plan or to-do list is a small shared workspace, but a planner fixes the order instead of the board's contents.
- Prompt Chaining: passing values by named keys between fixed steps is the lightest use of a shared store, with no content-driven choice of who acts next.
- Hierarchical teams: a shared artifact store across teams is a light blackboard. MetaGPT's role hierarchy is covered there, its message pool here.
- ReAct: each specialist is usually a ReAct loop, and in the volunteer variant the requester's "request help" is one of its actions.
- Human-in-the-Loop: a human can be one more knowledge source that approves decisions, resolves conflicts or validates entries before they become authoritative.
Further reading
- Exploring Advanced LLM Multi-Agent Systems Based on Blackboard Architecture (Han and Zhang, arXiv, 2025): the bMAS design with an LLM control unit, public and private spaces, and ablations on control and cleanup.
- LLM-based Multi-Agent Blackboard System for Information Discovery in Data Science (Salemi et al., arXiv, 2025): request boards with volunteer helpers, compared with master–slave and RAG baselines as the data lake grows.
- Building a C compiler with a team of parallel Claudes (Anthropic Engineering, 2026): 16 agents coordinating through a git repo and lock files, with the problems they hit.
- Blackboard system (Wikipedia): the three classic components, Hearsay-II, BB1 and deployed systems, with links to the original papers.
- Graph API (LangGraph docs): typed shared state, reducers and supersteps, the parts you need to build a board in a graph framework.
- Agent teams (Claude Code docs): a shared task list with self-claiming and file locking, and advice on splitting files between teammates.