Multi-Agent Coordination Patterns: Five Approaches and When to Use Them

When it comes to building multi-agent systems, choosing the right coordination pattern can make or break your project. In a previous post, we discussed when multi-agent systems are beneficial over single agents. Now, for teams that have decided on a multi-agent approach, this article delves into five key coordination patterns, their trade-offs, and how to evolve from one pattern to another as your system grows.

Pattern 1: Generator-Verifier

Overview: The generator-verifier pattern is the simplest and most widely used in multi-agent systems. It’s particularly useful when output quality is critical and evaluation criteria are explicit. Here’s how it works:

• Generator: Receives a task and produces an initial output.
• Verifier: Evaluates the output against predefined criteria. If the output meets the criteria, it's accepted; otherwise, feedback is provided to the generator for revision.

Implementation:

• The loop continues until the verifier accepts the output or a maximum number of iterations is reached.
• This pattern is effective in scenarios where quality control is paramount, such as generating email responses, code generation (one agent writes code, another writes and runs tests), fact-checking, rubric-based grading, and compliance verification.

Example: Imagine a customer support system where the generator produces an initial response to a ticket. The verifier checks for accuracy against the knowledge base, tone against brand guidelines, and ensures all issues are addressed. If any criteria fail, specific feedback is sent back to the generator for revision.

Pattern 2: Orchestrator-Subagent

Overview: The orchestrator-subagent pattern is ideal for tasks that can be clearly decomposed into bounded subtasks. The orchestrator manages the overall process, delegating specific tasks to subagents and integrating their outputs.

Implementation:

• Orchestrator: Breaks down the main task into smaller, well-defined subtasks.
• Subagents: Execute these subtasks and return results to the orchestrator.
• This pattern is useful for complex workflows where each step can be isolated and managed independently, such as data processing pipelines or multi-stage decision-making processes.

Example: In a data processing pipeline, the orchestrator might break down the task into data ingestion, cleaning, transformation, and analysis. Each subagent handles its specific part, ensuring that the final output is coherent and complete.

Pattern 3: Agent Teams

Overview: Agent teams are designed for parallel, independent, long-running subtasks. This pattern allows multiple agents to work simultaneously on different aspects of a problem, enhancing efficiency and scalability.

Implementation:

• Agents: Work independently on their assigned tasks.
• Coordination is minimal, with each agent focusing on its specific domain.
• Useful for scenarios where tasks can be executed in parallel without significant interdependencies, such as distributed data analysis or simultaneous user interactions.

Example: In a content recommendation system, multiple agents could analyze different user segments simultaneously, providing personalized recommendations based on their findings.

Pattern 4: Message Bus

Overview: The message bus pattern is ideal for event-driven pipelines where the agent ecosystem grows over time. It facilitates communication between agents through a centralized messaging system.

Implementation:

• Message Bus: Acts as a central hub for all communications.
• Agents send and receive messages to coordinate actions and share data.
• This pattern is particularly useful in dynamic environments where new agents can be added or existing ones modified without disrupting the overall system.

Example: In a real-time analytics platform, various agents might send and receive events through a message bus to update dashboards, trigger alerts, and perform other actions based on incoming data.

Pattern 5: Shared-State

Overview: The shared-state pattern is designed for collaborative work where agents build on each other's findings. It maintains a common state that all agents can access and modify.

Implementation:

• Shared State: A central repository of information that all agents can read from and write to.
• Agents update the shared state with their contributions, allowing others to build upon them.
• This pattern is useful for tasks requiring continuous collaboration and incremental progress, such as collaborative document editing or joint problem-solving.

Example: In a research project, multiple agents could contribute to a shared document, each adding new insights and building on previous findings to