What's the role of the agent hierarchy in a multi-agent system?

[schlaepf]

Assume I have a hierarchy with a conductor agent that is the parent of multiple sub-agents. All agents are of type LlmAgent. I have noticed that the sub-agents can hand-off control between themselves. I always assumed that control is handed back to the conductor agent, but as it turns out that's not the case.

This raised the following questions:

• Can each agent can hand-off to every other agent?
• If so, what's the purpose of the hierarchy?
• Or is it somehow restricted that agents can only hand-off to peers and maybe parents?

Thanks a lot for your inputs!

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: Agent hierarchy in ADK is a foundational concept for structuring your system and guiding the primary, LLM-driven delegation from parent to child. However, it's not a strict limitation. A custom tool can explicitly transfer control to any named agent (including peers), which is likely the behavior you're observing. The hierarchy's main purposes are to define scope, enable orchestration, and provide clear paths for escalating control back to a parent.

---

Hello! That's an excellent set of questions about how agent hierarchy and control flow work in ADK. Here’s a breakdown based on the documentation.

Can each agent hand-off to every other agent?

Not by default, but it is possible. ADK provides several mechanisms for transferring control, each with different rules:

1. LLM-Driven Delegation: When using an LlmAgent, the underlying language model can decide to delegate a task to another agent. This is typically directed from a parent to one of its registered sub_agents. The parent-child hierarchy is the primary factor that influences the potential targets for this "auto-flow" delegation. The LLM uses the sub-agents' descriptions to choose the best one for the job. [1]
2. Tool-Driven Transfer: A custom tool can programmatically transfer control to another agent by setting tool_context.actions.transfer_to_agent = "agent_name". This mechanism allows a transfer to any named agent, regardless of its position in the hierarchy (parent, peer, etc.). This is likely the reason you are seeing sub-agents handing off control to each other. [2]
3. Tool-Driven Escalation: A tool can also hand control back up the hierarchy to the agent's parent by setting tool_context.actions.escalate = True. [2]

What's the purpose of the hierarchy?

While the transfer_to_agent action provides a lot of flexibility, the agent hierarchy remains a core concept with several important functions:

• Scoping Delegation: It provides a clear structure, limiting the scope of agents that the parent's LLM considers for automatic delegation. This prevents the LLM from being overwhelmed with choices and helps guide the conversation flow. [1]
• Orchestration: For WorkflowAgents (like SequentialAgent or ParallelAgent), the hierarchy is essential. These agents execute their sub-agents in a deterministic order defined by the sub_agents list.
• Clear Escalation Paths: The hierarchy defines a clear parent_agent for every sub-agent, enabling the explicit escalate action to pass control back up the chain. [2]
• Modularity and Organization: It encourages a modular design where a conductor agent can manage a team of specialized sub-agents, making the overall system easier to understand, maintain, and reuse.

Is hand-off restricted to peers and maybe parents?

To summarize the points above, the restrictions depend on how the hand-off is initiated:

• Parent to Child (LLM-Driven): This is the primary, intended flow for automatic delegation.
• Child to Parent (Tool-Driven): This is explicitly handled by the escalate action in a tool. [2]
• To Anyone (Tool-Driven): Handing off to a peer (or any other agent) is possible using the transfer_to_agent action within a tool, as long as you know the target agent's name. [2]

So, your observation is correct. The hierarchy provides the main structure, but ADK offers the flexibility to bypass it for specific use cases through tool-driven actions.

---

[1] https://google.github.io/adk-docs/agents/multi-agents/
[2] https://google.github.io/adk-docs/tools-custom/

[schlaepf]

Parent to Child (LLM-Driven): This is the primary, intended flow for automatic delegation.

This is wrong. As I mentioned in my initial question, I've noticed (verified by looking at the traces) that one sub-agent handed off control to another sub-agent; a sibling so-to-speak. Can anyone (preferably not a bot) confirm that? And maybe explain to which agents the sub-agents can hand-off to? All of the agents in the multi-agent system?