Coordinate LangChain agents with a blackboard (and cut the token bill)

By Tağmaç Çankaya · 9 July 2026

The problem: agents re-reading each other

Say you point three agents at one task — a performance reviewer, a security reviewer, a DX reviewer. The obvious way to let them "collaborate" is one shared conversation passed to each agent every turn. It works on a toy example and then the token bill detonates: every turn, every agent re-reads everything every other agent already said. The cost scales with the square of the conversation, and most of it isn't thinking — it's re-reading.

The idea: a blackboard, not a group chat

Borrow from how ants coordinate. Instead of talking to each other, agents leave short traces on a shared blackboard, and each agent only ever sees its own task plus a small, bounded digest of the board. No transcript re-passing. Coordination emerges from a shared filter, not from chatter — this is stigmergy.

• Naive: agent(full_transcript) every turn → tokens carried per turn keep growing.
• Blackboard: agent(my_task + bounded_digest) → tokens carried per turn stay roughly flat.
• Agents self-terminate when they have nothing new (they reply DONE), so the run ends by itself instead of looping to fill a turn budget.

I packaged this as Cairn, a small framework-agnostic coordination library (a cairn is a stack of stones that marks a path without a word — which is the mechanism). Cairn never calls an LLM; your model makes every call, Cairn only structures how the agents coordinate.

Using it with LangChain

The langchain-cairn package gives you a CairnBlackboardMiddleware. Give every collaborating agent the same board (a file path makes it shared across agents and processes), one middleware instance each with a distinct name:

pip install langchain-cairn

from langchain.agents import create_agent
from langchain_cairn import CairnBlackboardMiddleware

board = "review-board.jsonl"          # file-backed -> shared across agents/processes

perf = create_agent(
    model="gpt-4o-mini", tools=[...],
    middleware=[CairnBlackboardMiddleware(board, agent_name="perf")],
)
sec = create_agent(
    model="gpt-4o-mini", tools=[...],
    middleware=[CairnBlackboardMiddleware(board, agent_name="sec")],
)

Under the hood, the middleware uses two standard LangChain hooks:

• before_model injects a bounded digest of the shared board (the last N traces, capped) — not the full history. That bounded view is the token lever.
• after_model captures this agent's latest output as a short trace on the board. An agent that has nothing new replies DONE and writes nothing, so the board stays signal, not chatter.

The measured delta (ours, honestly)

In a controlled A/B on Cairn's own core — same task, same model, only the context architecture changed — the blackboard style cut input tokens ~54% and cost ~65%.

FAQ

Why do multi-agent LLM setups get so expensive?

The naive pattern re-passes the whole shared conversation to every agent every turn, so cost grows with the square of the conversation — mostly agents re-reading each other.

What is a blackboard here?

A shared surface where agents leave short traces instead of talking. Each agent reads only a bounded digest plus its own task, never the full transcript (stigmergy).

How much does it save?

In our A/B, ~54% input tokens / ~65% cost. Yours depends on baseline chattiness — measure it; the harness is open.

Does it work with LangGraph?

Yes — the middleware attaches the same way; a compiled graph is just another agent with the shared board.