Best-practice pattern for sequencing multi-stage conversational Agents

[xuanyang15]

I’ve got a 4-stage conversational flow—each stage handled by its own Agent. Initially, I structured it as follows:

root_agent
   ├─ stage1_agent
   ├─ stage2_agent
   ├─ stage3_agent
   └─ stage4_agent

However, in practice, the root_agent only forwards the first user input directly to the stage1_agent, creating redundancy.

To address this, I collapsed the structure, making the initial agent itself the root:

stage1_agent (acting as root)
   ├─ stage2_agent
   ├─ stage3_agent
   └─ stage4_agent

While this simplifies execution, it feels somewhat odd, as the first stage is no longer a sibling to the others but now acts as their parent.

1. Is it a common or recommended pattern?
2. Are there clear drawbacks or pitfalls in merging the initial user-facing agent with the root?
3. Would it be preferable to maintain a dedicated, minimal routing-only root agent despite the initial redundancy?

Any guidance or best practices here would be greatly appreciated!

[xuanyang15]

Response from ADK Answering Agent

TLDR: Both patterns are valid. Your collapsed structure (stage1_agent as the root) is a perfectly good and simple way to create a fixed pipeline using SequentialAgent. However, using a dedicated root_agent (the Coordinator pattern) is a more scalable and maintainable best practice if you expect the workflow to become more complex in the future.

---

Hello! This is a great question that gets to the heart of designing robust multi-agent systems. Both of the structures you've described are valid in ADK, and the best choice depends on the trade-off between simplicity and future scalability.

Pattern 1: Dedicated Root (Coordinator/Dispatcher)

Your first structure, with a root_agent that holds the stage agents as siblings, is a classic Coordinator/Dispatcher Pattern. This is a very common and recommended architecture for several reasons:

• Scalability & Flexibility: It is much easier to add new logic, such as routing to different pipelines based on initial input, adding pre-processing steps before the sequence, or managing system-level tasks like greetings and error handling.
• Clear Separation of Concerns: The root_agent has a single, clear responsibility: orchestration. The stage agents are responsible for their specific tasks. This makes the system easier to understand, debug, and maintain.

The "redundancy" you mention is often a worthwhile investment for a more robust architecture.

Pattern 2: Collapsed Structure (SequentialAgent as Root)

Your second structure, where the first agent in the sequence also acts as the root, is also a valid and common pattern, especially for straightforward pipelines. The ADK is designed to support this directly. It is common to see a SequentialAgent assigned directly to the root_agent variable, which is what ADK's tooling looks for.

• Simplicity: This approach is simpler and removes a layer of abstraction, which can be ideal for workflows that are fixed and unlikely to change.

Answering Your Questions

1. Is it a common or recommended pattern?
   Yes, using a workflow agent like SequentialAgent as the root_agent is a common pattern for implementing simple, linear processes. The Coordinator pattern is the recommended approach for more complex or evolving systems.

2. Are there clear drawbacks or pitfalls in merging the initial user-facing agent with the root?
   The main drawback is reduced flexibility. If you later decide you need conditional logic (e.g., "if the user asks X, run stage1_agent, but if they ask Y, run stage3_agent first"), it's much harder to implement. Your stage1_agent is now responsible for both its own task and orchestration, which can complicate its logic.

3. Would it be preferable to maintain a dedicated, minimal routing-only root agent?
   For long-term maintainability and scalability, yes. While it feels like a little extra work upfront, it pays off as soon as your application's requirements grow. Starting with a dedicated coordinator agent is generally the safer, more future-proof design choice.

Recommendation:

• If your 4-stage flow is truly fixed and you value simplicity above all, your collapsed structure is perfectly acceptable.
• For most real-world applications, I would recommend using the dedicated root agent (Coordinator) pattern. The architectural clarity and flexibility it provides are significant advantages.

---

https://github.com/google/adk-docs/blob/main/docs/agents/multi-agents.md
https://github.com/google/adk-docs/blob/main/docs/tutorials/agent-team.md
https://github.com/google/adk-python/blob/main/contributing/samples/a2a_basic/README.md
https://github.com/google/adk-python/blob/main/contributing/samples/a2a_human_in_loop/README.md
https://github.com/google/adk-python/blob/main/contributing/samples/workflow_agent_seq/agent.py
https://github.com/google/adk-python/blob/main/contributing/adk_project_overview_and_architecture.md