1What if I cannot say in advance who should work on what?
Every agent reads and writes one shared workspace, the board. Each round, agents state what they could add given the board's current content, and a controller lets the most useful one write. The order of work emerges from the problem itself.
You may need it if
- The right next step depends on what was just discovered.
- Several kinds of expertise are needed, in an order nobody can script.
- Partial findings from one agent often unlock work for another.
2When is a shared board the wrong tool?
Use it when
- The problem is open-ended, such as analysis, diagnosis or design.
- Contributions build on each other in ways that are hard to predict.
- You want a full record of who contributed what, and when.
Avoid it when
- The subtasks and their order are known before starting. The bidding rounds are then pure overhead.
Use Supervisor & Specialists instead - The task is a fixed sequence of steps with a clear check after each one.
Use Plan–Execute–Verify instead - The budget is tight. Every round costs one call per agent just to bid.
What it costs
- Model calls
- rounds × (agents + 1) + 1 (often 15 to 30)
- Latency
- high
- Complexity
- high
3How does work move when nobody is in charge of the order?
There is no pipeline. The controller posts the problem on the board. Each round all specialists read the board and bid, one writes, and the controller checks whether the board now holds enough. A synthesizer then turns the board into the result.
- Step 1 of 5
The problem goes on the board
The controller writes the problem as the first entry. From now on the board, not a plan, is what every agent works from.
- Step 2 of 5
Everyone reads, everyone bids
Each specialist reads the whole board and says in one line what it could add now and how useful that would be. Many will pass.
- Step 3 of 5
One agent writes
The controller grants the turn to the most useful bid. That specialist adds one signed entry to the board. Nobody else writes this round.
- Step 4 of 5
The board has changed, so bid again
The new entry may unlock work for a different specialist. The controller rereads the board and opens the next round.
- Step 5 of 5
From board to result
When no bid adds value, or the round limit is reached, the synthesizer reads the board and writes the result from its entries only.
What each part does
- Problem
- The open-ended problem and the form of the expected result.
- Controller
- Posts the problem, collects bids, grants one turn per round and decides when to stop.
- Specialists
- Each reads the board, bids on what it could add, and writes when it wins the turn.
- Board
- The shared workspace. An ordered list of entries, each signed by its author.
- Synthesizer
- Reads the final board and writes the result from it.
- Result
- The result, with the board as its supporting record.
- Controller → Board: posts the problem
- Controller → Specialists: best bid gets the turn
- Specialists → Board: one entry
- Specialists → Controller: turn done
- Controller → Synthesizer: board sufficient or rounds spent
Where it connects
An open-ended problem and a description of the result expected at the end.
When: No bid adds value any more, or the round limit is reached.
The result written from the board, followed by the board entries in order with their authors.
An append-only list of short signed entries. Every agent reads all of it. Only the turn winner writes.
4What do I ask my assistant to set up?
The agents to launch
Controller
Keep the board. Each round, collect one bid per specialist and grant the turn to the bid that moves the problem forward most. After each write, decide whether the board holds enough to produce the result. Never write content entries yourself.
Sees: The problem, the whole board and the bids of the current round.
Specialist, three to five, each with a distinct expertise suited to the problem
Read the board. Reply with a bid: one line on what you would add and a usefulness score from 0 to 10, or pass. If you are granted the turn, write one entry of at most 120 words, signed with your role, that builds on existing entries.
Sees: The whole board and its own expertise description. Not the other specialists' bids.
Synthesizer
Write the result in the expected form using only what is on the board. If entries conflict, say so and state which one you followed and why.
Sees: The problem and the final board.
A prompt you can paste
Works with any assistant that can launch sub-agents. It contains the agents, the procedure and the stop rule above.
You are the orchestrator of a multi-agent workflow that follows the "Blackboard" architecture. Launch every agent listed below as a separate sub-agent with its own context. Give each agent only the context stated for it. Do not do an agent's work yourself. If you cannot launch sub-agents, play each agent in a clearly separated turn and never let it use what is withheld from it. # Task [Describe your task here] # Blackboard Specialists build a solution together on one shared board. Input: the task above. It must provide: An open-ended problem and a description of the result expected at the end. If something essential is missing, ask for it before starting. Agents to launch: - Controller: Keep the board. Each round, collect one bid per specialist and grant the turn to the bid that moves the problem forward most. After each write, decide whether the board holds enough to produce the result. Never write content entries yourself. Context for this agent: The problem, the whole board and the bids of the current round. - Specialist (three to five, each with a distinct expertise suited to the problem): Read the board. Reply with a bid: one line on what you would add and a usefulness score from 0 to 10, or pass. If you are granted the turn, write one entry of at most 120 words, signed with your role, that builds on existing entries. Context for this agent: The whole board and its own expertise description. Not the other specialists' bids. - Synthesizer: Write the result in the expected form using only what is on the board. If entries conflict, say so and state which one you followed and why. Context for this agent: The problem and the final board. Procedure: 1. Choose three to five specialist roles suited to the problem and launch each as a separate agent. Launch the controller. 2. Create the board as a numbered list and have the controller post the problem as entry 1. 3. Run a round: send the board to every specialist, collect the bids, let the controller grant one turn, append the winner's entry to the board. 4. After each round, ask the controller whether the board is sufficient. If not, run another round. 5. Launch the synthesizer on the final board. Stop rule: Stop the rounds when the controller declares the board sufficient, when every specialist passes, or after 6 rounds. Exit: - `result`, when: No bid adds value any more, or the round limit is reached. Deliver: The result written from the board, followed by the board entries in order with their authors. # Final deliverable The result, then the full board with entry numbers and authors, then the number of rounds used.
The same thing in code
import operator
from typing import Annotated, TypedDict, cast
from langchain.chat_models import init_chat_model
from langgraph.graph import START, StateGraph
from langgraph.types import Send
from pydantic import BaseModel
llm = init_chat_model("anthropic:claude-sonnet-5-5")
MAX_ROUNDS = 6
SPECIALISTS = { # choose three to five roles suited to the problem
"Market analyst": "customers, competitors and demand",
"Engineer": "what can be built, how long it takes and what breaks",
"Finance lead": "costs, margins and cash",
}
class Bid(BaseModel):
wants_turn: bool # false means pass
offer: str # one line on what it would add
usefulness: int # 0 to 10
class Grant(BaseModel):
specialist: str
why: str # one line, so the turns do not become a monologue
class Sufficient(BaseModel):
sufficient: bool
class Input(TypedDict):
problem: str
class State(Input):
board: Annotated[list[str], operator.add] # the blackboard: signed entries, append only
bids: Annotated[list[tuple[int, str, Bid]], operator.add]
round: int
turn: str
sufficient: bool
result: str
class BidTask(TypedDict):
role: str
board: list[str]
round: int
def show(board: list[str]) -> str:
return "\n".join(f"{i}. {entry}" for i, entry in enumerate(board, 1))
async def post(state: State) -> dict:
return {"board": [f"[Controller] Problem: {state['problem']}"], "round": 0, "sufficient": False}
def open_round(state: State) -> list[Send] | str:
if state["sufficient"] or state["round"] >= MAX_ROUNDS: # stop at 6 rounds
return "synthesizer"
return [Send("bid", {"role": r, "board": state["board"], "round": state["round"] + 1})
for r in SPECIALISTS]
async def bid(state: BidTask) -> dict:
# a specialist sees the board and its own expertise, never the other bids
offer = cast(Bid, await llm.with_structured_output(Bid).ainvoke(
f"You are the {state['role']}, expert in {SPECIALISTS[state['role']]}.\n"
f"Board:\n{show(state['board'])}\n"
"Bid one line on what you would add with a usefulness score from 0 to 10, or pass."))
return {"bids": [(state["round"], state["role"], offer)]}
async def grant(state: State) -> dict:
rnd = state["round"] + 1
bids = [f"{role}: {b.offer} ({b.usefulness}/10)"
for r, role, b in state["bids"] if r == rnd and b.wants_turn]
if not bids: # every specialist passed
return {"round": rnd, "turn": ""}
pick = cast(Grant, await llm.with_structured_output(Grant).ainvoke(
"Grant the turn to the bid that moves the problem forward most; justify it in one line.\n"
f"Board:\n{show(state['board'])}\nBids:\n" + "\n".join(bids)))
return {"round": rnd, "turn": pick.specialist}
async def write(state: State) -> dict:
role = state["turn"]
entry = await llm.ainvoke(
f"You are the {role}, expert in {SPECIALISTS.get(role, role)}. Write one entry of at most 120 "
f"words that builds on existing entries.\nBoard:\n{show(state['board'])}")
return {"board": [f"[{role}] {entry.text}"]}
async def check(state: State) -> dict:
verdict = cast(Sufficient, await llm.with_structured_output(Sufficient).ainvoke(
f"Problem: {state['problem']}\nBoard:\n{show(state['board'])}\n"
"Does the board hold enough to produce the result?"))
return {"sufficient": verdict.sufficient}
async def synthesizer(state: State) -> dict:
reply = await llm.ainvoke(
"Write the result using only what is on the board. If entries conflict, say which one you "
f"followed and why.\nProblem: {state['problem']}\nBoard:\n{show(state['board'])}")
return {"result": reply.text}
graph = StateGraph(State, input_schema=Input)
graph.add_node("post", post)
graph.add_node("bid", bid)
graph.add_node("grant", grant)
graph.add_node("write", write)
graph.add_node("check", check)
graph.add_node("synthesizer", synthesizer)
graph.add_edge(START, "post")
graph.add_conditional_edges("post", open_round)
graph.add_edge("bid", "grant")
graph.add_conditional_edges("grant", lambda s: "write" if s["turn"] else "synthesizer")
graph.add_edge("write", "check")
graph.add_conditional_edges("check", open_round)
app = graph.compile()
async def run(task: str):
final = await app.ainvoke({"problem": task})
return {"result": final["result"], "board": final["board"], "rounds": final["round"]}
Generate the specialist roles from the problem instead of the fixed three, and add a checkpointer so a long board survives restarts.
import asyncio
from claude_agent_sdk import AgentDefinition, ClaudeAgentOptions, ResultMessage, query
from pydantic import BaseModel
MAX_ROUNDS = 6
SPECIALISTS = { # choose three to five roles suited to the problem
"market-analyst": "customers, competitors and demand",
"engineer": "what can be built, how long it takes and what breaks",
"finance-lead": "costs, margins and cash",
}
class Bid(BaseModel):
wants_turn: bool # false means pass
offer: str
usefulness: int # 0 to 10
class Grant(BaseModel):
specialist: str
why: str
class Sufficient(BaseModel):
sufficient: bool
AGENTS = {
role: AgentDefinition(
description=f"Specialist in {expertise}.",
prompt=f"You are expert in {expertise}. Read the board. To bid, give one line on what you "
"would add and a usefulness score from 0 to 10, or pass. When granted the turn, write one "
"entry of at most 120 words that builds on existing entries.",
tools=[])
for role, expertise in SPECIALISTS.items()
} | {
"controller": AgentDefinition(
description="Grants turns on the board and decides when it holds enough.",
prompt="Grant the turn to the bid that moves the problem forward most and justify it in one "
"line, or judge whether the board holds enough. Never write content entries yourself.",
tools=[]),
"synthesizer": AgentDefinition(
description="Turns the final board into the result.",
prompt="Write the result using only what is on the board. If entries conflict, say which "
"one you followed and why.",
tools=[]),
}
async def delegate(agent: str, brief: str, schema: type[BaseModel] | None = None) -> ResultMessage:
# one query per call: a new session, so each agent sees only what it is handed
options = ClaudeAgentOptions(
agents=AGENTS, allowed_tools=["Agent"],
output_format={"type": "json_schema", "schema": schema.model_json_schema()} if schema else None)
prompt = f"Delegate this to the {agent} agent and return its answer unchanged.\n\n{brief}"
async for message in query(prompt=prompt, options=options):
if isinstance(message, ResultMessage):
return message
raise RuntimeError(f"{agent} returned no result")
async def run(task: str):
board = [f"[controller] Problem: {task}"] # the blackboard: signed entries, append only
show = lambda: "\n".join(f"{i}. {e}" for i, e in enumerate(board, 1))
rounds = 0
while rounds < MAX_ROUNDS: # stop at 6 rounds
rounds += 1
# every specialist bids on the same board; none sees another's bid
replies = await asyncio.gather(*(
delegate(r, f"Bid on this board:\n{show()}", Bid) for r in SPECIALISTS))
bids = {r: Bid.model_validate(m.structured_output) for r, m in zip(SPECIALISTS, replies)}
offers = "\n".join(f"{r}: {b.offer} ({b.usefulness}/10)" for r, b in bids.items() if b.wants_turn)
if not offers: # every specialist passed
break
pick = Grant.model_validate((await delegate(
"controller", f"Board:\n{show()}\nBids:\n{offers}\nGrant one turn.", Grant)).structured_output)
first = next(r for r, b in bids.items() if b.wants_turn)
winner = pick.specialist if pick.specialist in SPECIALISTS else first
entry = (await delegate(winner, f"You have the turn. Write your entry.\nBoard:\n{show()}")).result
board.append(f"[{winner}] {entry}")
done = Sufficient.model_validate((await delegate(
"controller", f"Problem: {task}\nBoard:\n{show()}\nDoes it hold enough for the result?",
Sufficient)).structured_output)
if done.sufficient:
break
result = (await delegate("synthesizer", f"Problem: {task}\nFinal board:\n{show()}")).result
return {"result": result, "board": board, "rounds": rounds}
Generate the specialist definitions from the problem instead of the fixed three, and give specialists tools only where their expertise needs them.
import asyncio
from agents import Agent, Runner
from pydantic import BaseModel
MAX_ROUNDS = 6
SPECIALISTS = { # choose three to five roles suited to the problem
"Market analyst": "customers, competitors and demand",
"Engineer": "what can be built, how long it takes and what breaks",
"Finance lead": "costs, margins and cash",
}
class Bid(BaseModel):
wants_turn: bool # false means pass
offer: str
usefulness: int # 0 to 10
class Grant(BaseModel):
specialist: str
why: str
class Sufficient(BaseModel):
sufficient: bool
writers = {
role: Agent(name=role, instructions=f"You are expert in {expertise}. When granted the turn, "
"write one entry of at most 120 words that builds on existing board entries.")
for role, expertise in SPECIALISTS.items()
}
bidders = {
role: w.clone(instructions=f"You are expert in {SPECIALISTS[role]}. Read the board and bid one "
"line on what you would add with a usefulness score from 0 to 10, or pass.",
output_type=Bid)
for role, w in writers.items()
}
controller = Agent(
name="Controller",
instructions="Grant the turn to the bid that moves the problem forward most and justify it in "
"one line. Never write content entries yourself.",
output_type=Grant,
)
checker = controller.clone(
instructions="Decide whether the board holds enough to produce the result.", output_type=Sufficient)
synthesizer = Agent(
name="Synthesizer",
instructions="Write the result using only what is on the board. If entries conflict, say which "
"one you followed and why.",
)
async def run(task: str):
board = [f"[Controller] Problem: {task}"] # the blackboard: signed entries, append only
show = lambda: "\n".join(f"{i}. {e}" for i, e in enumerate(board, 1))
rounds = 0
while rounds < MAX_ROUNDS: # stop at 6 rounds
rounds += 1
# separate runs: each specialist sees the board, never the other bids
runs = await asyncio.gather(*(Runner.run(b, f"Board:\n{show()}") for b in bidders.values()))
bids = {role: r.final_output_as(Bid) for role, r in zip(bidders, runs)}
offers = "\n".join(f"{r}: {b.offer} ({b.usefulness}/10)" for r, b in bids.items() if b.wants_turn)
if not offers: # every specialist passed
break
pick = (await Runner.run(controller, f"Board:\n{show()}\nBids:\n{offers}")).final_output_as(Grant)
first = next(r for r, b in bids.items() if b.wants_turn)
winner = pick.specialist if pick.specialist in writers else first
entry = (await Runner.run(writers[winner], f"Board:\n{show()}")).final_output
board.append(f"[{winner}] {entry}")
done = await Runner.run(checker, f"Problem: {task}\nBoard:\n{show()}")
if done.final_output_as(Sufficient).sufficient:
break
result = (await Runner.run(synthesizer, f"Problem: {task}\nFinal board:\n{show()}")).final_output
return {"result": result, "board": board, "rounds": rounds}
Generate the specialist roles from the problem instead of the fixed three, and log each grant's one-line justification next to the board.
import { anthropic } from '@ai-sdk/anthropic';
import { generateText, Output } from 'ai';
import { z } from 'zod';
const model = anthropic('claude-sonnet-5-5');
const MAX_ROUNDS = 6;
// choose three to five roles suited to the problem
const SPECIALISTS: Record<string, string> = {
'Market analyst': 'customers, competitors and demand',
Engineer: 'what can be built, how long it takes and what breaks',
'Finance lead': 'costs, margins and cash',
};
const bidSchema = z.object({
wantsTurn: z.boolean().describe('false means pass'),
offer: z.string(),
usefulness: z.number().int().min(0).max(10),
});
const grantSchema = z.object({ specialist: z.string(), why: z.string() });
export async function run(task: string) {
const board = [`[Controller] Problem: ${task}`]; // the blackboard: signed entries, append only
const show = () => board.map((e, i) => `${i + 1}. ${e}`).join('\n');
let rounds = 0;
while (rounds < MAX_ROUNDS) { // stop at 6 rounds
rounds++;
// separate calls: each specialist sees the board and its expertise, never the other bids
const bids = await Promise.all(
Object.entries(SPECIALISTS).map(async ([role, expertise]) => {
const { output } = await generateText({
model,
instructions:
`You are expert in ${expertise}. Bid one line on what you would add ` +
'with a usefulness score from 0 to 10, or pass.',
prompt: `Board:\n${show()}`,
output: Output.object({ schema: bidSchema }),
});
return { role, ...output };
}),
);
const open = bids.filter((b) => b.wantsTurn);
if (open.length === 0) break; // every specialist passed
const { output: pick } = await generateText({
model,
instructions:
'Grant the turn to the bid that moves the problem forward most and justify it ' +
'in one line. Never write entries yourself.',
prompt: `Board:\n${show()}\nBids:\n${open.map((b) => `${b.role}: ${b.offer} (${b.usefulness}/10)`).join('\n')}`,
output: Output.object({ schema: grantSchema }),
});
const winner = SPECIALISTS[pick.specialist] ? pick.specialist : open[0].role;
const { text: entry } = await generateText({
model,
instructions:
`You are expert in ${SPECIALISTS[winner]}. Write one entry of at most 120 words ` +
'that builds on existing entries.',
prompt: `Board:\n${show()}`,
});
board.push(`[${winner}] ${entry}`);
const { output: check } = await generateText({
model,
instructions: 'Decide whether the board holds enough to produce the result.',
prompt: `Problem: ${task}\nBoard:\n${show()}`,
output: Output.object({ schema: z.object({ sufficient: z.boolean() }) }),
});
if (check.sufficient) break;
}
const { text: result } = await generateText({
model,
instructions:
'Write the result using only what is on the board. If entries conflict, say which ' +
'one you followed and why.',
prompt: `Problem: ${task}\nFinal board:\n${show()}`,
});
return { result, board, rounds };
}
Generate the specialist roles from the problem instead of the fixed three, and log each grant's justification next to the board.
Snippets are generated when the site is built and type-checked against the SDK versions listed in the repository. Treat them as a starting skeleton.
What goes wrong
- Without a round limit, specialists keep finding marginal additions and the cost grows with every round.
- Long entries bury earlier findings. Cap entry length and keep entries factual.
- A controller that always picks the same specialist turns the board into a monologue. Have it justify each grant in one line.
Chain it
Its result can feed
- Reflection direct
Treat the synthesized result as an existing draft to improve: score it against explicit criteria and rewrite until it passes, using the board entries as background.
- Chain of Verification conditional
Condition: Build the link only when the blackboard's result is an answer, not a document.
- Debate conditional
Condition: Build the link only when the blackboard's result is an answer, not a document.
- Constitutional Critique direct
Treat the synthesized result as the text to check against every rule of the constitution, and fix only the rules that fail.
- Textual Backpropagation direct
Treat the blackboard's synthesized result as the existing result to improve against the original task. Use the signed board entries as supporting material for the first step.
Source
- Erman et al., 1980. The Hearsay-II Speech-Understanding System