Agentic Architectures

Catalogue / Multi-agent Coordination

Blackboard

Specialists build a solution together on one shared board

Shape
shared-state
Model calls
rounds × (agents + 1) + 1 (often 15 to 30)
Latency
high
Complexity
high
1

What 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.
2

When 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

What it costs

Model calls
rounds × (agents + 1) + 1 (often 15 to 30)
Latency
high
Complexity
high
3

How 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.

best bid getsthe turnturn doneboardsufficient orrounds spentProblem: The open-ended problem and the form of the expected result.ProblemController: Posts the problem, collects bids, grants one turn per round and decides when to stop.ControllerSpecialists: Each reads the board, bids on what it could add, and writes when it wins the turn.SpecialistsBoard: The shared workspace. An ordered list of entries, each signed by its author.BoardSynthesizer: Reads the final board and writes the result from it.SynthesizerResult: The result, with the board as its supporting record.Result
  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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

Entry
problem
TaskQuestion

An open-ended problem and a description of the result expected at the end.

Exit
result
AnswerDocument

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.

Working memory for one run
board
EvidenceDraftPlan

An append-only list of short signed entries. Every agent reads all of it. Only the turn winner writes.

4

What 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.

Framework-agnostic prompt
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

LangGraph, python, package langgraph
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.

Claude Agent SDK, python, package claude-agent-sdk
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.

OpenAI Agents SDK, python, package openai-agents
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.

Vercel AI SDK, typescript, package ai
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

Source

  • Erman et al., 1980. The Hearsay-II Speech-Understanding System