L3 · 03 · Multi-Agent Systems & Orchestration

One agent with the right tools solves most tasks. Multi-agent systems help when work is long-running, splits into independent subtasks, or benefits from a critic that isn't the author. This page covers the patterns that work in production, the coordination costs nobody mentions in demos, and agent-to-agent protocols.

Start with the honest question

The patterns that work

Artefacts, not conversations

The biggest practical rule: agents pass artefacts (files, JSON, summaries), not their full message histories. A worker returns "here are the 3 findings with citations", not 40 messages of exploration. This keeps each agent's context clean, makes results testable, and lets you swap agents without rewiring anything.

from concurrent.futures import ThreadPoolExecutor


def make_worker(model, role: str):
    def work(task: str) -> dict:
        # In production this is a real model call with the role as system prompt.
        # Returns an artefact (dict), not a conversation.
        return model(f"[{role}] {task}")
    return work


def orchestrate(task: str, subtasks: list[str], workers, merge) -> dict:
    with ThreadPoolExecutor(max_workers=len(subtasks)) as pool:
        artefacts = list(pool.map(lambda t: workers[t[0]](t[1]),
                                  enumerate(subtasks)))
    return merge(task, artefacts)


if __name__ == "__main__":
    # Scripted stand-ins: each "worker" returns a fake finding.
    scripted = lambda model: make_worker(model, "researcher")
    workers = [scripted(lambda p: {"finding": p[:40], "source": "doc-A"}),
               scripted(lambda p: {"finding": p[:40], "source": "doc-B"}),
               scripted(lambda p: {"finding": p[:40], "source": "doc-C"})]

    def merge(task, artefacts):
        return {"task": task, "n_findings": len(artefacts),
                "sources": sorted({a["source"] for a in artefacts})}

    result = orchestrate(
        "Why did pickup cancellations spike in June?",
        ["check order logs", "check staffing rota", "check promotion calendar"],
        workers, merge)
    print(result)

Three workers run in parallel, each returns a small artefact, and merge is plain code you can unit-test. That's the skeleton of every orchestrator–worker system.

The costs nobody mentions

• Tokens multiply. An orchestrator that replays each worker's output pays for every token twice. Artefacts keep this bounded.
• Errors compound. Three stages at 90% accuracy each → ~73% end-to-end. Add checks between stages, not just at the end.
• Latency adds up serially in pipelines; parallel workers pay the max, not the sum.
• Debugging gets hard fast. Log every artefact passed between agents with run IDs — you'll need them (L3·07).
• Determinism where possible. If a step is just "format these results", write code, not a prompt.

Agents talking to agents: A2A and ACP

MCP connects a model to tools. Agent-to-agent protocols connect agents to agents — one agent delegating a task to another, possibly across organisations or runtimes.

These matter when agents live in different systems (your support agent calls a vendor's logistics agent). Inside one codebase, a function call is still simpler and better. The field is young — expect the spec names and versions to keep moving; the patterns above are the durable knowledge.

Permissions differ per agent — that's a feature

Separation of duties is a security pattern, not just an org chart: the drafting agent can read the ticket queue; the sending agent can send replies but not read the whole queue; the critic can only read. Each agent gets least-privilege tools (L2·09), and a compromise of one doesn't compromise the rest. L3·08 goes deeper.