	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Multi-Agent Systems

ADK Multi-Agent Systems

Author: Venkata Sudhakar

In ADK, an agent can use other agents as tools - this is the multi-agent pattern. A coordinator agent receives the user request, reasons about what needs to be done, and delegates subtasks to specialised sub-agents. Unlike SequentialAgent where the order is fixed in code, the coordinator decides dynamically which agents to call based on the conversation context. This gives you the flexibility of dynamic routing combined with the specialisation benefits of dedicated agents - each sub-agent is an expert in its domain and the coordinator orchestrates them intelligently without hard-coded routing logic.

In ADK you expose sub-agents to a coordinator using AgentTool. The coordinator sees each sub-agent as a callable tool with a description. It calls them by passing a query string, the sub-agent processes it with its own tools and instructions, and returns a response. The coordinator then decides whether to call another agent or provide a final answer. This nesting can go multiple levels deep for complex enterprise workflows - coordinators can call other coordinators, building a hierarchy that mirrors your organisational structure.

The below example builds an HR onboarding system: a coordinator routes new employee queries to three specialist agents - one for HR policies, one for IT system access, and one for desk and equipment assignments - delegating dynamically based on what the employee asks.

from google.adk.agents import Agent
from google.adk.tools import AgentTool
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types as genai_types

# Tools for specialist agents
def get_hr_policy(topic: str) -> dict:
    # Returns HR policy details for a given topic
    policies = {
        "leave":      "18 EL + 12 CL + 12 SL per year. Apply via HR portal with 3 days notice.",
        "probation":  "6-month probation with reviews at month 3 and month 6.",
        "work hours": "9am-6pm standard. WFH up to 2 days per week after probation.",
        "salary":     "Paid on last working day. Slips available on HR portal."
    }
    for key in policies:
        if key in topic.lower():
            return {"policy": policies[key]}
    return {"policy": "Contact HR at hr@company.in for this topic."}

def provision_access(system_name: str, employee_id: str) -> dict:
    # Provisions system access for a new employee
    systems = {
        "email":     {"status": "auto-provisioned", "eta": "already active"},
        "jira":      {"status": "provisioned",       "eta": "active in 1 hour"},
        "github":    {"status": "requires manager approval", "eta": "2-4 hours"},
        "confluence": {"status": "provisioned",      "eta": "active in 30 minutes"}
    }
    info = systems.get(system_name.lower(), {"status": "contact IT", "eta": "unknown"})
    return {"system": system_name, "employee_id": employee_id, **info}

def assign_workspace(employee_id: str, department: str) -> dict:
    # Assigns desk and equipment to a new employee
    setups = {
        "engineering": {"floor": "3rd", "zone": "Tech Bay B",
                        "equipment": ["Dell XPS 15", "27-inch Monitor", "Standing Desk"]},
        "sales":       {"floor": "2nd", "zone": "Sales Hub",
                        "equipment": ["MacBook Pro", "Headset"]},
        "hr":          {"floor": "1st", "zone": "HR Suite",
                        "equipment": ["HP Laptop", "Desk Phone"]}
    }
    setup = setups.get(department.lower(), {"floor": "TBD", "equipment": ["Standard laptop"]})
    return {"employee_id": employee_id, "department": department,
            "desk_id": department[:2].upper() + "-" + employee_id[-3:], **setup}

# Three specialist sub-agents
policy_agent = Agent(
    model="gemini-2.0-flash", name="hr_policy_agent",
    instruction=(
        "You are an HR policy specialist. "
        "Use get_hr_policy to answer policy questions accurately with specifics."
    ),
    tools=[get_hr_policy]
)

it_agent = Agent(
    model="gemini-2.0-flash", name="it_provisioning_agent",
    instruction=(
        "You are an IT provisioning specialist. "
        "Use provision_access to set up system access. "
        "Always confirm system name and activation time."
    ),
    tools=[provision_access]
)

facilities_agent = Agent(
    model="gemini-2.0-flash", name="facilities_agent",
    instruction=(
        "You are a facilities coordinator. "
        "Use assign_workspace to allocate desks and equipment. "
        "Confirm all assignment details clearly."
    ),
    tools=[assign_workspace]
)

# Coordinator uses sub-agents as tools via AgentTool
coordinator = Agent(
    model="gemini-2.0-flash", name="onboarding_coordinator",
    instruction=(
        "You are an HR onboarding coordinator. "
        "Use your specialist agents as tools: "
        "hr_policy_agent for HR policy questions, "
        "it_provisioning_agent for system access, "
        "facilities_agent for desk and equipment. "
        "For complex queries call multiple agents. Be warm and welcoming."
    ),
    tools=[
        AgentTool(agent=policy_agent),
        AgentTool(agent=it_agent),
        AgentTool(agent=facilities_agent)
    ]
)

Running three different onboarding queries through the coordinator,

sessions = InMemorySessionService()
runner   = Runner(agent=coordinator, app_name="hr_onboarding", session_service=sessions)

def ask_coordinator(user_id: str, question: str) -> str:
    content = genai_types.Content(
        role="user", parts=[genai_types.Part(text=question)]
    )
    final = ""
    for event in runner.run(user_id=user_id, session_id="s1", new_message=content):
        if event.is_final_response():
            final = event.content.parts[0].text
    return final

# Single topic query
print("Q1: What is the leave policy for new employees?")
print(ask_coordinator("EMP-8821", "What is the leave policy for new employees?"))

# IT access query
print("\nQ2: I need access to Jira and GitHub. My employee ID is EMP-8821.")
print(ask_coordinator("EMP-8821", "I need access to Jira and GitHub. My ID is EMP-8821."))

# Multi-topic query - coordinator calls multiple agents
print("\nQ3: I am joining the Engineering team as EMP-8821. "
      "What is my desk, what equipment will I get, "
      "and how many leave days do I have in my first year?")
print(ask_coordinator("EMP-8821",
    "Joining Engineering team as EMP-8821. What desk, equipment, and annual leave?"))

It gives the following output showing the coordinator routing to the right specialist,

Q1: What is the leave policy for new employees?
[Coordinator routes to: hr_policy_agent]
Welcome! Our leave policy gives you 18 days Earned Leave, 12 days Casual Leave,
and 12 Sick Leave days per year - a total of 42 days. You apply through the
HR portal with at least 3 days notice for planned leave. Is there anything
else about your benefits you would like to know?

Q2: I need access to Jira and GitHub. My employee ID is EMP-8821.
[Coordinator routes to: it_provisioning_agent x2]
Your Jira access has been provisioned and will be active within 1 hour.
For GitHub, manager approval is required first - your access will be
activated within 2-4 hours of your manager approving the request. You
will get an email confirmation for both. Welcome aboard!

Q3: Joining Engineering team as EMP-8821. What desk, equipment, and annual leave?
[Coordinator routes to: facilities_agent AND hr_policy_agent]
Here is everything you need to know:
DESK: EN-821 on the 3rd Floor, Tech Bay B zone.
EQUIPMENT: Dell XPS 15 laptop, 27-inch monitor, and a standing desk.
LEAVE: 42 days total (18 EL + 12 CL + 12 SL) applied via HR portal.
You are all set - welcome to the Engineering team!

# Q3: Coordinator autonomously called TWO specialist agents from one query
# No routing rules written - Gemini decided from the instruction which agents to use

Multi-agent systems with AgentTool are ideal when you have genuinely different domains of expertise that benefit from separate tools, instructions, and reasoning contexts. The coordinator instruction is the most important piece - describe each sub-agent clearly so the coordinator knows when to use it. Test edge cases: what does the coordinator do when a query spans all three agents? Does it call all three? Test with five to ten realistic queries before deployment. For production, add logging inside each tool and sub-agent to build an audit trail of every delegation decision and sub-agent response.

Send your comments, suggestions or queries regarding this site to [email protected].