Introduction
In our previous lesson, we established the communication and coordination topologies for multi-agent systems, distinguishing between shared knowledge and message-passing paradigms. We looked at high-level architectures like the supervisor, deterministic flow, and swarm models. This gave us the "who talks to whom" map of an agentic system.
Now, we will move from the map to the engine room. This lesson addresses the core mechanisms that bring these architectures to life, focusing on the learning outcome: to explain architectural mechanisms for coordination, task delegation, and decomposition among agents. We will investigate how a complex problem is broken down, how sub-tasks are assigned to the right agents, and how their work is orchestrated to achieve a final goal.
For someone with your background in system design, you can think of these mechanisms as the design patterns of agentic architectures. They provide reusable solutions to common problems in coordinating intelligent, non-deterministic components, much like traditional design patterns do for object-oriented or distributed systems.
The Foundation: Task Decomposition
Before any work can be delegated or coordinated, a complex goal must first be broken down into smaller, solvable pieces. This process, known as task decomposition, is arguably the most critical step in designing a multi-agent system. A chaotic, all-at-once approach where every agent tries to solve the whole problem leads to wasted effort and conflicting actions.
A structured, hierarchical approach is the standard solution.
A formal method for this is Hierarchical Goal Decomposition, where a parent agent defines a chain of responsibility, creating clear vertical hand-offs to child agents.
10 Multi-Agent Coordination Strategies to Prevent System ...
This article from Galileo.ai outlines several key strategies for building reliable multi-agent systems. We'll start with its take on decomposition.
Please read the section titled "Deploy hierarchical goal decomposition." Pay close attention to the six-step coordination loop (Divide, Evaluate, Plan, Act, Reflect, Track) it describes. This provides a robust mental model for the decomposition process.
The DEPART framework mentioned in the article provides a useful lifecycle for decomposition. A top-level agent divides the problem, specialized agents act on the sub-problems, and the system reflects and tracks progress.
This "Russian Doll" approach, where agents contain other agents, is a powerful pattern. A high-level agent might not perform any action itself other than delegating parts of its task to sub-agents and synthesizing their results.
The following image provides a clear visual for this process.
Let's now examine the practical patterns that implement this philosophy. The Google Developers blog post on multi-agent patterns provides excellent, code-level examples.
Developer's guide to multi-agent patterns in ADK
This guide uses Google's Agent Development Kit (ADK) to illustrate several essential design patterns.
Read section 4, "Hierarchical decomposition." Notice how a sub-agent (research_assistant) can be wrapped in an AgentTool, allowing the parent agent (report_writer) to call it just like any other tool. This is a key implementation detail for delegation.
Mechanisms for Task Delegation
Once a task is decomposed, the sub-tasks must be delegated to the appropriate agents. The mechanism for this delegation is a defining architectural choice.
1. The Coordinator/Dispatcher Pattern
In this model, a central agent acts as an intelligent router or "concierge." It analyzes an incoming request, determines the user's intent, and delegates the task to the most suitable specialist agent. This is ideal for systems that handle a variety of distinct tasks, like a customer service bot.
Developer's guide to multi-agent patterns in ADK
Let's return to the Google Developers guide to see how this pattern is implemented.
Read section 2, "Coordinator/Dispatcher Pattern." The critical insight here is that the delegation is LLM-driven. The coordinator agent uses the description fields of its sub-agents to decide where to route the request. This makes the description a form of API documentation for the LLM.
2. The Sequential Pipeline Pattern
This is the simplest delegation pattern, analogous to a factory assembly line or a Unix pipe. The output of Agent A becomes the input for Agent B in a fixed, linear sequence. It's deterministic, easy to debug, and perfect for multi-step data processing workflows.
Developer's guide to multi-agent patterns in ADK
Now, let's examine the pipeline pattern in the same guide.
Read section 1, "Sequential Pipeline Pattern." Note the emphasis on state management. The output_key is used to write to a shared state, which is the mechanism for the hand-off.
3. The Parallel Fan-Out/Gather Pattern
For tasks that can be performed independently, running them sequentially is inefficient. This pattern, which you'll recognize from parallel computing, involves delegating multiple sub-tasks to be executed simultaneously. A final "gather" or "synthesizer" agent then aggregates the results. This reduces latency and can also be used to gather diverse perspectives on a single problem.
Developer's guide to multi-agent patterns in ADK
The guide offers a great example of this pattern for automated code review.
Read section 3, "Parallel Fan-Out/Gather Pattern." The key architectural consideration here is preventing race conditions. Since agents share a session state, they must write their outputs to unique keys to avoid overwriting each other's work.
Mechanisms for Coordination
Delegating tasks is only half the battle. The agents' activities must be coordinated to ensure they work together effectively, handle disagreements, and produce high-quality output.
1. Coordination via Feedback Loops
Instead of a simple hand-off, agents can engage in a loop to iteratively improve the quality of work. This introduces a quality control checkpoint into the workflow.
- Generator-Critic: One agent generates content, and a second "critic" agent validates it against a set of rules (e.g., is this valid SQL? Does it pass compliance checks?). If the output fails validation, it's sent back to the generator with feedback.
- Iterative Refinement: This is a more qualitative version. A generator produces a draft, a critic provides suggestions for improvement, and a third "refiner" agent incorporates the feedback. This loop can run for a fixed number of iterations or until a desired quality score is met.
Developer's guide to multi-agent patterns in ADK
The Google guide clearly distinguishes between these two powerful feedback patterns.
Read section 5, "Generator and critic," and section 6, "Iterative refinement." Notice the difference in focus: the Generator-Critic pattern is about correctness (pass/fail), while Iterative Refinement is about qualitative improvement.
2. Coordination via Consensus
What happens when multiple agents have valid but conflicting opinions? For example, in the parallel code review pattern, the Security Auditor might flag a line that the Performance Analyst insists is necessary. A coordination mechanism is needed to resolve such conflicts.
10 Multi-Agent Coordination Strategies to Prevent System ...
Let's revisit the Galileo.ai article for a strategy on resolving disagreements.
Read the section titled "Harmonize decisions with consensus voting." As someone with a CS background, the mention of Byzantine Fault Tolerance (BFT) should be familiar. The core idea is the same: to create a system that can reach a reliable decision even in the presence of faulty or disagreeing nodes (agents).
This voting mechanism can be implemented by a synthesizer or orchestrator agent, which collects the outputs from multiple agents and applies a rule—such as a simple majority or a weighted score based on confidence—to arrive at a final decision.
Conclusion
In this lesson, we have dissected the architectural machinery that powers multi-agent systems. We've moved beyond high-level topologies to the specific patterns for breaking down problems, delegating work, and coordinating actions.
Key Takeaways:
- Decomposition is Foundational: Hierarchical goal decomposition is the primary strategy for breaking down complex problems into manageable sub-tasks for a team of agents.
- Delegation Patterns are Your Toolkit: You can delegate tasks using several patterns, including the Coordinator/Dispatcher for intelligent routing, the Sequential Pipeline for linear workflows, and the Parallel Fan-Out/Gather for independent tasks.
- Coordination Ensures Coherence: Simple delegation isn't enough. Coordination mechanisms like Iterative Feedback Loops (Generator-Critic, Refinement) enforce quality, while Consensus Mechanisms (Voting) resolve disagreements among agents.
- Patterns Compose: Just like in software engineering, these patterns are not mutually exclusive. A robust system will often combine them, for instance, using a Coordinator to route a task to a parallel workflow that uses a Generator-Critic loop internally.
Preview of the Next Lesson:
We have now designed the core workflow of a multi-agent system. But what happens when an agent fails, gets stuck in a loop, or is about to perform a high-stakes, irreversible action? Our architecture needs safety nets. The next lesson will focus on self-regulation mechanisms, including monitoring, fallbacks, and the crucial Human-in-the-Loop pattern, to ensure our agentic systems operate not just effectively, but also safely and responsibly.