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:

A question goes to a supervisor that must pick one of four helpers; it sends a temperature question to the observation-log agent, which does not hold that data. Question noise vs temperature Supervisor routes every sub-question must know who holds what relays every result Observation logs asked about temperature Instrument telemetry Calibration notes Web search
The supervisor is the only path between the question and the data, so its picture of what each helper holds decides whether the right helper is ever asked.

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.

  1. 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.
  2. 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.
  3. 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") with supports links to the evidence ids.
  4. 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.
  5. 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

A blackboard with sections sits in the middle; specialist agents on both sides read and write it; a control unit above reads the board and activates agents; a decider below writes the solution. board state activates activates Control unit reads board, picks agents Blackboard task + decisions requests evidence hypotheses critiques solution File agent logs cluster File agent telemetry cluster Web search public sources Analyst writes hypotheses Critic flags weak entries Housekeeping cleanup, conflicts Decider enough? write solution 1 2 3 4 5
Two-headed lines: an agent reads the part of the board it needs and writes entries back. The dashed line is the board state the control unit reads; accent lines are its activations, which reach every agent in a column. No line joins two agents.
  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.

Board sections one row per section
Specialists one row per agent
Who decides who acts next

Generated prompt

Highlighted text comes from the form. [Bracketed] text is still to fill in.

The board view matters more than the prompts

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

Avoid it when

How to implement

  1. 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.
  2. Design the schema. Sections, entry types, statuses, required fields and who may write where. Keep content as natural language but make id, author, status, supports and supersedes machine fields, and add a decisions section that every writer must respect.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. Add housekeeping. Conflict detection, superseding, removal of redundant entries, and compaction of old rounds into one summary entry.
  8. 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).
  9. 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 support (check current docs before use)
FrameworkShared storeWhere the control comes from
LangGraphTyped 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 ADKSession 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
MetaGPTA shared message pool; roles publish structured documents and subscribe to the types they needSubscriptions, inside a largely fixed SOP order
Claude Code agent teamsA shared task list (pending, in progress, completed, with dependencies) plus per-agent mailboxesThe lead assigns, or teammates self-claim with file locking
LettaMemory blocks attached to several agents; concurrent writes: last write winsYour own code
CrewAIOne unified Memory shared by the crew when memory=TrueThe crew process (sequential or hierarchical), so shared memory rather than a controlled board
AWS StrandsShared context passed along a Swarm: task, agent history, contributed knowledgeHandoffs, so a light board inside a Swarm
Plain files and gitA repo with code, notes, progress files and lock filesAgents 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 bash and 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 status and supersedes fields, 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 supports links 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

Further reading