Where the blackboard pattern shows up under different names in modern frameworks

Flashcard·Medium·4.0 · 0·~30s·Asked atInfosys Krutrim Lyzr

Attempt it

Blackboard reappears as the 'shared state' or 'shared scratchpad' in modern frameworks. LangGraph's typed state dict with per-key reducers is the cleanest contemporary version: every agent reads the same state, returns a partial update, and a reducer function (append for messages, overwrite for status, custom merge for nested fields) merges deterministically. CrewAI calls a related primitive 'shared memory' and AutoGen's GroupChat passes a shared message log that plays the same role.

What the modern version adds over the 1970s original: typed schemas instead of loosely-structured key-value entries, deterministic reducers that make parallel writes safe, integration with checkpointing for resume after failure, and first-class observability of every read and write. The core idea (agents coordinate through a shared workspace rather than direct messages) is unchanged.

Your answer

The blackboard pattern is one of the oldest coordination patterns in AI. The metaphor is a literal blackboard in a room of experts. Each expert can read what is on the board, add their contribution when they see something they can help with, and step back. A control component decides who writes next. There is no direct communication between the experts; the board is the only channel. In 2026 frameworks, this pattern reappears under several names. The closest match is LangGraph's state. You define a typed dictionary, every agent reads and returns updates to that dictionary, and the framework merges the updates using reducer functions you specify per key (for example, append for a list of messages, overwrite for a status flag). CrewAI calls a similar primitive shared memory, and AutoGen's GroupChat passes a shared list of messages that every participant reads. The implementations differ, but the principle is the same: coordinate through a shared workspace, not through direct messages. The modern additions are typing (you know what shape the state has), deterministic merges (so parallel writes do not corrupt anything), checkpointing (you can pause, resume, or time-travel), and built-in observability of every read and write.

The **blackboard pattern** asks experts to coordinate through a shared workspace instead of through direct messages. A control component schedules which expert runs next based on what is currently on the board. Hearsay-II, the 1970s speech-understanding system, was the canonical example. The pattern reappears across the 2026 framework landscape under different names. LangGraph's typed state is the cleanest version: a Pydantic-style schema declares the state shape, every node returns a partial dict, and a reducer per key controls merging. Append reducers handle message lists, overwrite reducers handle status fields, and custom reducers handle anything in between. CrewAI exposes a 'shared memory' primitive that crew members read; AutoGen's GroupChat keeps a shared message log that all participants see; smolagents agents share a Python namespace through code as action. What the modern version adds over the 1970s original is engineering rigour. Typed schemas catch shape errors at definition time instead of at runtime. Per-key reducers make parallel writes deterministic, which is essential for fan-out patterns. Checkpointing snapshots the state to durable storage so workflows can pause, resume, and time-travel. Every read and write is an observable event, which is what gives modern multi-agent systems their LangSmith-grade tracing. The core idea is unchanged; the contract around it is professional.

TL;DR

The blackboard pattern lives on as LangGraph's typed state with reducers, CrewAI's shared memory, and AutoGen's shared message log; the modern version adds types, deterministic merges, and checkpointing.

Memory aid

Easy to grasp

Picture a classroom whiteboard where several students take turns adding to a group project. The first writes the topic, another adds a sketch, another fills in numbers, and a fourth circles the conclusion. Nobody passes notes; everyone just looks at the board. That is the blackboard idea from old AI textbooks. Today, the whiteboard is digital: it has labelled sections, rules about what can go in each section, and a small helper who decides how to combine two students writing at the same time. That helper, the labels, and the ability to take a photo so you can rewind to an earlier state are what modern frameworks added on top of the old idea.

Key concepts

Multi-agent systems LLM frameworks Agents

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Software architecture has a quiet rule: every good idea gets re-invented every fifteen years under a new name. The blackboard pattern is a case study. It appeared in classical AI in the 1970s, fell out of fashion as object-orientation and direct message passing took over in the 1980s and 1990s, and quietly returned in the 2020s as the dominant coordination primitive in multi-agent LLM frameworks.

The modern version does not call itself a blackboard. It calls itself state, shared memory, or a message log. The framing is updated, the engineering is much better, but if you squint past the vocabulary the structural commitments are nearly identical.

What the original blackboard pattern actually was

The blackboard pattern crystallised around the Hearsay-II speech-understanding system at Carnegie Mellon in the mid-1970s. The problem was hard: turn a continuous audio signal into a sentence, using whatever combination of acoustic, phonetic, syntactic, and semantic clues helped on a given utterance.

The solution had three components.

The blackboard. A globally readable, hierarchically structured workspace that held partial hypotheses at every level (signal, phoneme, word, phrase).
Knowledge sources (KS). Independent expert modules, each specialised for one kind of inference. A KS watched the blackboard for trigger conditions and contributed when it saw work it could do.
The scheduler. A control component that picked which KS to run next based on what was currently on the board and what was estimated to be most valuable.

The key architectural commitment was that KS did not talk to each other. They only read and wrote the blackboard. This made it possible to add a new KS without modifying any existing one, which was the whole point: speech understanding needed dozens of partial experts, and tightly coupling them would have made the system impossible to extend.

Why it returned as 'state' in modern frameworks

What the modern version adds: types, reducers, checkpoints

Where the pattern breaks and what to do about it

Situations where this technique stops working.

2–4 min · Everything important, quickly.

python

from typing import Annotated, TypedDict
import operator
from langgraph.graph import StateGraph, END

class ResearchState(TypedDict):
    question: str
    hits: Annotated[list[str], operator.add]  # reducer: append
    status: str                                # reducer: overwrite (default)

def worker_a(state: ResearchState) -> ResearchState:
    return {"hits": ["hit from A"], "status": "a-done"}

def worker_b(state: ResearchState) -> ResearchState:
    return {"hits": ["hit from B"], "status": "b-done"}

g = StateGraph(ResearchState)
g.add_node("a", worker_a)
g.add_node("b", worker_b)
g.set_entry_point("a")
g.add_edge("a", "b")
g.add_edge("b", END)

Real products, models, and research that use this idea.

LangGraph's `StateGraph` API in production at companies like Klarna and Replit for agent workflows that need parallel fan-out and resume after failure.
CrewAI's shared memory primitive used in content-generation crews where a researcher, a writer, and an editor all read the same evolving brief.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow would you design a reducer for a nested-object state field where two agents update different sub-keys in parallel?

Define a deep-merge reducer that takes both partial dicts and merges at the leaves, with a tie-break rule (last write wins or per-leaf reducer) for conflicting keys.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Conflating 'shared state' with a free-form dict that any agent can clobber. The win is in the typed schema plus the per-key reducer, which is what makes parallel writes safe.

60 second bullets to scan on the way to the call.

The 1970s blackboard pattern and its Knowledge Source plus scheduler shape
Why direct message passing differs from shared-workspace coordination

Primary sources. Browse if you want the original framing.