Multi-Agent System Patterns

1. The Building Blocks: Orchestration and Communication

Before diving into specific patterns, it's helpful to understand two fundamental aspects that define them:

1. Orchestration: How is the workflow controlled? Is it a fixed, predefined sequence, or does an LLM-powered agent dynamically decide what happens next? We can categorize patterns as either deterministic (like a script) or agentic (dynamic and adaptive).
2. Communication: How do agents share information? As we'll see, this is often handled through a shared "state" object that all agents can read from and write to, or by one agent "calling" another as if it were a tool and passing parameters.

Let's watch a brief segment that explains these communication methods.

This distinction is key. Communication via a shared state allows for richer, more flexible collaboration, while tool-calling creates a more rigid, function-like interaction. Most patterns we discuss can be implemented using either method, but the choice has implications for flexibility and control.

2. Deterministic Patterns: The Assembly Line

Deterministic patterns are best for structured, repeatable processes where the sequence of operations is known in advance. They are analogous to a traditional ETL pipeline or an assembly line—predictable, efficient, and easier to debug. Because the flow is hardcoded, they don't rely on an LLM for orchestration, which can reduce latency and cost.

The Google Cloud document "Choose a design pattern for your agentic AI system" provides excellent descriptions of these patterns.

Let's summarize these core deterministic patterns:

• Sequential Pattern: Agents execute one after another in a linear chain. The output of Agent A becomes the input for Agent B. This is perfect for data processing pipelines, like parsing a document, then extracting entities, and finally summarizing the content.

• Parallel Pattern (Fan-Out/Gather): Multiple agents work simultaneously on independent sub-tasks. Their outputs are then aggregated. This is great for reducing latency. For example, you could have three agents simultaneously analyze a product review for sentiment, topics, and urgency, with a final agent synthesizing their findings.

• Loop-based Patterns (e.g., Review and Critique): A sequence of agents runs repeatedly until a condition is met. The Review and Critique (or Generator-Critic) pattern is a powerful example.

  • A Generator agent creates content (e.g., a SQL query).
  • A Critic agent evaluates it against specific criteria (e.g., "Is this valid SQL?").
  • If it fails, the feedback is sent back to the Generator for another attempt. This loop ensures a certain level of quality or correctness.

3. Agentic Patterns: The Management Team

These patterns use an LLM-powered agent to dynamically orchestrate the workflow, making decisions at runtime about which agent or tool to use next. This provides far more flexibility to handle varied inputs and unexpected situations.

The Coordinator / Supervisor Pattern

This is arguably the most common and useful agentic pattern. A central "supervisor" or "coordinator" agent acts like a project manager, analyzing a request and routing it to the appropriate specialist agent.

This architecture is elegantly explained in another Google resource.

Let's break down these hierarchical concepts:

• Coordinator (or Supervisor): A single manager agent delegates tasks. It doesn't do the work itself; it directs traffic. For example, a customer service coordinator might receive a query, determine if it's a billing or technical issue, and route it to the BillingSpecialist or TechSupportSpecialist agent.

• Hierarchical Pattern: This is simply a multi-level coordinator pattern—a manager of managers. A top-level agent breaks a very complex goal (e.g., "write a research report on AI trends") into large sub-tasks (gather data, analyze findings, draft report). It delegates each sub-task to a mid-level coordinator, which might further decompose the task and delegate to worker agents that use specific tools (like a WebSearchAgent).

4. Collaborative Patterns: The Brainstorm Session

While hierarchical patterns impose top-down control, some problems benefit from a more flexible, bottom-up collaboration where agents can communicate freely.

The Swarm / Collaborative Broadcast Pattern

In this pattern, agents can communicate with any other agent in the group, resembling a brainstorming session or a group chat. A dispatcher might kick off the process, but there is no central manager dictating the workflow. Agents can debate, share findings, and hand off tasks to whomever is best suited for the next step.

Key Trade-offs of Swarm Patterns:

• Pro: Highly flexible and resilient. If one agent gets stuck, another can jump in. This can lead to more creative and robust solutions for ambiguous, open-ended problems.
• Con: Can be chaotic, inefficient, and costly. Without a clear supervisor, agents might loop unproductively or fail to converge on a solution. The LangChain video (LINK) wisely cautions that these "network of agents" can be unreliable in production without very careful design.

Summary of Patterns

The Google Cloud documentation provides a helpful table that summarizes when to use each pattern based on the workload.

Conclusion

You now have a solid grasp of the fundamental design patterns for multi-agent systems. We've seen that the choice of pattern is a trade-off between control, flexibility, cost, and complexity.

Key Takeaways:

• Deterministic Patterns (Sequential, Parallel, Loop): Best for structured, predictable workflows. They are efficient and reliable, like an assembly line.
• Hierarchical Patterns (Coordinator, Hierarchical): Use a manager agent to dynamically route tasks. This provides flexibility and is ideal for automating complex business processes.
• Collaborative Patterns (Swarm): Allow for free-form, all-to-all communication. They are powerful for creative and ambiguous problems but risk being chaotic and inefficient.
• Composite Designs: Real-world systems rarely use just one pattern. The most robust solutions often combine multiple patterns to leverage the strengths of each.

In our next lesson, we will get practical again. We'll implement a simple two-agent collaboration pattern (a manager-worker duo), putting the Coordinator pattern into practice using LangGraph.