Multi-Agent Collaboration Patterns | 30 Days of AI Agents, Day 20

Yesterday we covered how a single agent plans and replans. Today is Multi-Agent Collaboration Patterns. Day 17 covered what a multi-agent system is made of. This post is a catalog of the six standard ways agents work together, and how to choose the right one for your problem.

Save this sheet. The rest of this note walks through it section by section.

What Collaboration Means Here

Multi-agent collaboration is when several AI agents work together, share information, and coordinate their actions to reach a goal that's too complex for one agent. Done well, it lets agents share knowledge and context, coordinate tasks and subtasks, use specialization, improve accuracy and reliability, and handle larger, real-world problems.

The phrase "done well" matters. A collaboration pattern is a decision about who decides what happens next: one supervisor, the agents themselves, a fixed sequence, or a shared workspace. Each answer has different costs.

The Collaboration Flow

The sheet's high-level flow, which every pattern implements in some form:

1. Goal / task. The user defines the overall goal.
2. Task decomposition. The orchestrator breaks the goal into subtasks.
3. Agent assignment. Agents with the right skills get each subtask.
4. Collaborate. Agents communicate, share information, and work together.
5. Integrate results. Outputs are combined and checked for consistency.
6. Final output. The result goes to the user.

Underneath sit the shared resources: shared memory (often a vector DB), a knowledge base, tools and services, a communication channel, and state and context management. Communicate → Coordinate → Collaborate → Validate → Complete.

The key components, from the sheet: an orchestrator that plans, assigns, monitors, and coordinates; specialized agents; a communication layer; shared memory; tools / APIs; an evaluator that validates results; and the environment the agents operate in.

Six Collaboration Patterns

Pattern	How it works	Best for
Supervisor (manager-worker)	One supervisor delegates to workers and reviews their output	Structured tasks, enterprise workflows
Peer-to-peer (decentralized)	Agents collaborate as equals with no central supervisor	Dynamic environments, exploration
Hierarchical	Multiple levels of managers, each with its own team	Large, complex systems
Pipeline	Each agent passes its output to the next in sequence: A → B → C	Sequential processes, data flows
Blackboard	Agents read and write a shared workspace and contribute when they can	Creative tasks, knowledge gathering
Swarm (emergent)	Many agents with minimal coordination, each following simple rules	Complex, open-ended problems

A few notes from building these:

• Pipeline is the most underrated. If your steps really are sequential, a pipeline is cheap, easy to test (each stage has a fixed input and output), and easy to debug. Many "multi-agent systems" should simply be pipelines.
• Supervisor is the most common production pattern. The supervisor is effectively a router. Keep it thin, so it decides who's next and checks results but doesn't do the work itself.
• Blackboard works well when you can't know in advance which specialist will be useful. Each agent watches the shared state and contributes when it has something relevant. It needs a clear rule for when the work is "done."
• Swarm is useful for open-ended exploration and research, and rarely appropriate for business processes that need a reliable, auditable outcome.

Choosing a Pattern

Three questions narrow it down quickly:

Are the steps known and ordered?            -> Pipeline
Is the next step decided by the situation?
   ...and must be auditable?                -> Supervisor
   ...across several independent teams?     -> Hierarchical
Do agents add to shared work opportunistically? -> Blackboard
Is the problem open-ended exploration?      -> Peer-to-peer or Swarm

Patterns also nest. A supervisor might hand off to a pipeline (research → draft → edit), and a hierarchical system is often just supervisors managing supervisors. Start with the simplest pattern that fits and add structure only where a real failure points to it.

Communication Patterns

How messages travel is a separate choice from who's in charge:

• Message passing. Agents send messages directly to each other.
• Publish / subscribe. Agents publish events, and subscribed agents react. In the sheet's example, Agent A publishes an event and Agents B, C, and D each receive it.
• Request / response. One agent asks and another answers.
• Broadcast. One agent sends to every available agent.

Supervisors and pipelines usually use request/response, because it's easy to trace. Blackboards are effectively pub/sub on shared state. Whichever you use, make messages structured (status, summary, artifact references), as covered on Day 17.

Example A Research Report System

The sheet's example is a six-agent pipeline with a supervisor's touch:

Planner (creates the plan and outline) → Researcher (searches and gathers data) → Analyst (analyzes and extracts insights) → Writer (writes the report) → Reviewer (reviews and improves) → Publisher (formats and publishes). All of them share a memory of sources, notes, facts, drafts, and feedback.

The architecture around it: an orchestrator agent (planner and coordinator), an agent registry listing available agents and their skills, a communication layer (for example LangGraph channels), shared memory, tools and services, and an evaluator that checks quality before the final output.

In code, the orchestration is short. The sheet's pseudocode, tightened with a review gate:

plan = planner_agent.create_plan(goal)
for task in plan.decompose():
    agent = orchestrator.assign_agent(task)      # pick from the registry by skill
    result = agent.execute(task, context=shared_memory.read(task.deps))
    shared_memory.store(task.id, result)

draft = writer_agent.write(shared_memory.collect(plan))
review = reviewer_agent.review(draft)
if review.approved:
    publisher_agent.publish(draft)
else:
    orchestrator.send_back(review.issues)        # bounded: max 2 revision rounds

The reviewer acts as a gate, not a suggestion. Nothing gets published without approval, and revision rounds are capped.

Frameworks Best Practices and Challenges

Frameworks that implement these patterns include LangGraph (stateful multi-agent graphs, a natural fit for supervisor and pipeline), CrewAI (role-based crews with sequential or hierarchical processes), AutoGen (conversation-driven teams), Semantic Kernel (Microsoft's SDK for orchestrating agents in enterprise apps), OpenAI's Agents SDK (agents that hand off to one another), and Google's Vertex AI Agent Builder (managed, enterprise-grade agents).

Best practices:

• Define clear goals and success criteria for the whole system and for each agent.
• Break tasks into small, assignable units.
• Choose the right pattern for the problem, not the most impressive one.
• Maintain shared context and memory, with namespaces per run.
• Use structured communication protocols.
• Validate and evaluate results continuously, not only at the end.
• Handle failures and retries gracefully.
• Monitor, log, and improve over time.

Challenges: complex coordination and orchestration, high communication overhead, inconsistent or conflicting outputs, context limits and memory management, error propagation between agents, higher cost and latency, debugging multi-agent systems, and designing reliable evaluation logic. Error propagation deserves special attention. In a pipeline, a bad research step poisons everything downstream, which is why validation between stages pays for itself.

Key Takeaways

• A collaboration pattern is a decision about who decides what happens next.
• Pipeline and supervisor cover most business use cases. Start there.
• Blackboard and swarm suit open-ended exploration, not auditable processes.
• Patterns nest, so combine simple ones before reaching for complex ones.
• Validate between stages, so one agent's error doesn't spread through the system.

FAQs

What's the difference between supervisor and hierarchical?

Hierarchical is supervisors stacked in levels. Use it only when sub-teams are large and independent enough to need their own manager.

Is a pipeline really multi-agent?

Yes, if each stage is an agent with its own role and tools. It's simply the most predictable kind.

Which pattern is cheapest?

Usually the pipeline, since there's no routing overhead. Supervisor patterns add a model call per routing decision.

Up Next

Day 21 is Evaluating AI Agents: how to build test sets, choose metrics, use LLM-as-a-judge responsibly, and track agent quality over time. If you're choosing a collaboration pattern for a real workflow and want it built properly, get in touch.