I once shipped a blackboard that nobody could see.

The storage layer worked perfectly. Every agent wrote to the shared state. The schema was clean, the writes were ordered, the persistence was durable. And in the first live run, one agent repeated the same line every turn while the others went silent — because the only thing each agent could actually see was its own section of the board.

The post-mortem in the ADR is four words long and still stings: “The shared blackboard wasn't shared.” Peer lines landed in agent_notes, the ContextBuilder never injected them, and agent.spoke wasn't in the globally visible set. Every agent acted in a vacuum. A small model with that prompt has nothing new to react to, so it loops.

That's when I understood that “shared context” is two different claims. The state is stored in one place. And each agent can actually see the part of it that bears on its work. The first is easy. The second is the entire problem.

The Channel That Loses Meaning by Design

I had spent months on message passing. Agent A produces a natural-language summary, hands it to Agent B, B summarizes, hands it to C. Each hop is a compression. Each compression is lossy.

The SE-Blackboard paper gives this a name and a measurement. Knowledge drift is “the cumulative loss or distortion of technical entities, identifiers, and references that occurs as task-relevant content is paraphrased through successive agent handoffs”. A function signature becomes “the function.” A stack trace becomes “an error.” A file path loses one character and the patch no longer applies.

The paper's framing is the one that reframes the architecture question: message passing doesn't just lose information, it guarantees loss at every boundary. The blackboard doesn't eliminate compression — but it stops putting compression in the critical path.

The Pattern That Predates the Problem

The blackboard is not a new idea. It came out of HEARSAY-II, a speech-understanding system built at Carnegie Mellon in the early 1970s under a DARPA programme.

The problem HEARSAY-II faced is the problem we face now. A stretch of speech admits several readings, and the knowledge that settles which one is right arrives in unrelated kinds — acoustic, lexical, syntactic, semantic. Which kind will settle a given stretch isn't known until that stretch is examined. So the system couldn't be written as procedures calling one another, because a call fixes what runs next. HEARSAY-II gave its specialists a shared structure instead. Each reads what bears on its own expertise and writes back what it concludes, and none of them calls another.

That last sentence is the whole pattern. The coordination isn't in the calls. It's in the structure.

What the 2026 Research Actually Measured

For decades the blackboard was an architecture in search of a problem. LLM agents gave it the problem back.

The SE-Blackboard paper ran 50 SWE-bench Lite issues through three communication architectures — message passing, shared-state blackboard, and a hybrid — inside an otherwise identical pipeline. The results:

  • Information Fidelity Score at the Coder stage: 0.586 vs. 0.362 — a 62% improvement over message passing.
  • Correct file targeting: 82.6% vs. 55.1% — a 27.5 percentage point gain.

That's the headline. But the paper's more important contribution is the honest part. Once the correct file was identified, all configurations converged to roughly a 22% conditional resolve rate. The upstream fidelity gain attenuated at the patch-generation stage. The end-to-end resolve rate improved only modestly — 16% vs. 12% — because the bottleneck had moved downstream.

I keep coming back to that finding because it's the opposite of a sales pitch. The blackboard is a measurable, separable design dimension, not a magic fix. It solves the information-preservation problem. It does not solve the diff-generation problem. Knowing which one you have is the whole game.

The Production Numbers Are Stranger Than the Benchmarks

The benchmark result is encouraging. The production deployment is the one that made me rebuild.

TaxBridge is a UK Making Tax Digital compliance engine. The team replaced a four-role LLM debate panel with a neuro-symbolic blackboard where LLMs are bounded heuristics that fire only when symbolic Knowledge Sources cannot resolve ambiguity. Against the system it replaced in production:

  • 100% ledger accuracy versus 0% for the debate panel.
  • 26× lower latency.
  • 29× lower token consumption.

The mechanism is the inversion. Instead of coordinating LLMs through a framework, the blackboard coordinates knowledge sources, and the LLM is one bounded participant among them. The symbolic layer does the deterministic work. The LLM handles the ambiguity the symbols can't. That's not a multi-agent system with a better message bus. It's a different allocation of cognition.

And the pattern extends beyond documents. ASIF — two autonomous agents on physically separate machines governing 21 software projects for 152 days — runs a brokerless, asynchronous coordination layer with no message broker, no shared database, no orchestration service. A five-minute cron performs git synchronization. In that window they produced 264 cross-machine handoff notes, 62 architecture decision records, and more than 180 governance standards through a single shared repository. The repository is the board. The commits are the writes. The sync is the read.

A Blackboard Is Not a Dictionary

Here's where most teams get it wrong, and where I got it wrong.

The first version of my rebuild was a shared key-value store. Every agent could read everything. It was shared, it was persistent, and it was useless. Agents drowned in context, read entries that had nothing to do with their step, and duplicated work because the board had no notion of relevance.

The ScaleMAS paper names the three problems precisely: reading burden that grows with the group, useful information diluted by shared work of unknown quality, and fragility to failed agents. Its critique of naive blackboards is exact: moving coordination into a shared medium “relieve[s] only the last problem”.

Their fix is the design I now use. Agents interact with the datastore through three operations:

  • publish a message, with optional references to earlier messages it builds on.
  • search by content, returning at most k messages, so an agent's read stays bounded at any group size.
  • visit a message by address.

Search results are ranked by relevance and by how often they are cited — which the paper finds to be an effective proxy for quality. Messages persist after their producers leave, so the group carries on when individual agents fail. ScaleMAS scales to 128 agents and tolerates losing agents midway.

That's the difference between a board and a substrate. A board stores. A substrate bounds the read, ranks the signal, and survives the writer.

The Failure Modes That Come With the Pattern

I want to be as clear about the costs as the benefits, because I've now broken this pattern in three different ways.

The Infinite Board Problem. The board grows until it exceeds the context window. A structured JSON object that started at five kilobytes can reach several megabytes in twenty iterations. And naive LRU eviction makes it worse: the least-recently-used item might be the original goal or the security constraint. You need architectural stratification — core, working memory, archive — semantic importance ranking, and a rule that active arguments are never pruned until consensus is reached. The board needs an eraser, and the eraser needs a policy.

Governance failures. The Governed Shared Memory paper formalizes four: unauthorized leakage, stale propagation, contradiction persistence, and provenance collapse. The primitives that address them are scoped retrieval, temporal supersession, provenance tracking, and policy-governed propagation — implemented in a production multi-tenant memory service and evaluated on a live harness. The paper's most useful contribution is the production bugs it found: sub-tenant scope initially bypassed on direct GET-by-id requests, and a synchronous near-duplicate gate that could reject a contradictory write before the asynchronous contradiction detector could evaluate it.

That second one is the kind of bug you only find by running the thing. The governance layer had a pipeline-ordering conflict that looked correct on a whiteboard and failed in production.

The board that isn't visible. My opening anecdote is the cheapest failure mode and the most common. The state is stored. The projection is missing. A blackboard without a per-agent projection layer is a database with a nicer name. And a blackboard that shows every agent everything is a context-saturation engine.

What Actually Makes It Work

The production systems that hold up converge on five design choices.

Scope the view, not just the store. Every agent reads a projection — global facts, workflow-scoped episodic memory, and role-scoped artifacts. Not a flat database where everyone sees everything. The blackboard pattern solves coupling because an agent doesn't need to know which other agents exist, only the schema of the board. But the schema has to support scoping, or the board becomes noise.

Make the board prose the agents can read natively. The Agentic Company OS revived the blackboard with one decisive change: the shared workspace is prose that the LLM and the human read natively, not an engineered representation that only purpose-built knowledge sources could parse. Agents exchange no out-of-band messages. They coordinate by writing to shared files, and the substrate serves as the message bus. That's the difference between a database and a shared workspace.

Keep an arbiter, but move what it arbitrates. Blackboard-Core still uses a Supervisor LLM to decide which agent runs next. The difference is that the supervisor is orchestrating over shared state rather than routing messages. The coordinator no longer has to hold the content in its context. It only has to read the board and pick the next contributor. That's a much cheaper job, and it survives context saturation.

Enforce the action boundary at the substrate. The Agentic Company OS makes the Sync Agent the only agent permitted to call external systems. Trust attaches to skills, not to agents — a sales agent can run qualify_lead at full autonomy while holding negotiate_contract at shadow on the same call. Every commit is signed and revertable, and every policy change is itself an artifact in the audit trail. The board isn't just memory. It's the governance surface.

Give the board a recovery property. The agent-boss shared memory bus was built for a specific failure: after a session compacts or resumes, the model reconstructs its understanding from scratch. Contradictory decisions, duplicated work, coordination breakdowns. Their measurement: an agent recovers to approximately 95% effectiveness after compaction, and the 5% loss is procedural memory, not factual knowledge. That's what a persistent board buys you — not perfect memory, but a warm start.

What the Blackboard Doesn't Fix

I've now defended this pattern enough to be honest about its limits.

It doesn't fix bad reasoning. A well-structured board carrying a wrong conclusion is still wrong. The board makes reasoning auditable — you can trace a claim back to the write that produced it — but it doesn't make it correct.

It doesn't eliminate the need for an arbiter. Someone still decides who writes next, what gets admitted, and when the run ends. Blackboard-Core has a supervisor. The Agentic Company OS has a Sync Agent and a trust gradient. The pattern distributes content, not control.

It doesn't give you a clean linear trace. A pipeline has one path. A blackboard has a write history and a projection graph. Debugging means reconstructing intent from a sequence of contributions that were never designed to be read as a narrative. That's the tax.

And it doesn't stop the board from becoming a dumping ground. The Infinite Board Problem is real, and it arrives on a schedule proportional to how much your agents like writing. Without stratification and pruning, the board becomes the context window's worst enemy.

What I'd Tell My Past Self

The message-passing architecture wasn't wrong because I used the wrong framework. It was wrong because it made paraphrase the transport layer. Every agent had to compress what it knew into prose so the next agent could read it, and every compression was a place where the constraint could become a suggestion.

The blackboard removes paraphrase from the transport path. The artifact stays where it was written. The receiving agent reads what it needs, in the form it was produced. The coordination moves from the conversation to the substrate.

That's why it's back. Not because it's fashionable. Because the failure mode it addresses — knowledge drift, context loss, agents operating on a representation that no longer reflects the problem — is the failure mode that scales with every agent you add.

The teams shipping this successfully aren't choosing between a blackboard and a graph. They're using the board as the memory substrate and the graph as the control plane. The board holds the truth. The graph decides who reads it next.

So here's my question: If you looked at what your agents can actually see right now, not what's stored in your shared state — how much of the board is reaching the prompt, and how much of your context loss is just a projection you never built?

I'd love to hear where you've landed. A shared workspace with scoped projections, a repository-as-board, a graph runtime where the blackboard never left — or a message-passing chain you're still defending, and what finally made you look at the substrate instead of the messages.