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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Supervisor Agent Pattern

ADK Supervisor Agent Pattern

Author: Venkata Sudhakar

The supervisor agent pattern is one of the most powerful patterns in multi-agent systems. A supervisor agent receives the user request, classifies the intent, delegates to the appropriate specialist agent, and then synthesises the results into a coherent response. This prevents any single agent from becoming a bloated catch-all.

In this tutorial, we build a ShopMax India customer support supervisor that routes queries to three specialist agents: a product agent, a returns agent, and an escalation agent. The supervisor decides which specialist handles each query and presents the final response.

The below example shows the supervisor and sub-agent setup using Google ADK FunctionTool and LlmAgent.

import os
from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from google.adk.sessions import InMemorySessionService
from google.adk.runners import Runner
from google.genai import types

# --- Specialist Agent 1: Product Info ---
def get_product_info(product_id: str) -> dict:
    """Return product details for ShopMax India inventory."""
    catalog = {
        "LP001": {"name": "Dell Inspiron 15", "price": 62000, "stock": 14, "warranty": "1 year"},
        "TV002": {"name": "Samsung 55 QLED", "price": 89000, "stock": 3, "warranty": "2 years"},
    }
    return catalog.get(product_id, {"error": "Product not found"})

product_agent = LlmAgent(
    name="product_specialist",
    model="gemini-2.0-flash",
    instruction="You are the ShopMax India product specialist. Use get_product_info to answer product queries.",
    tools=[FunctionTool(get_product_info)]
)

# --- Specialist Agent 2: Returns ---
def check_return_eligibility(order_id: str, days_since_purchase: int) -> dict:
    """Check if an order qualifies for return under ShopMax India policy."""
    eligible = days_since_purchase <= 30
    return {
        "order_id": order_id,
        "eligible": eligible,
        "policy": "30-day no-questions-asked return",
        "next_step": "Visit store with invoice" if eligible else "Return window closed"
    }

returns_agent = LlmAgent(
    name="returns_specialist",
    model="gemini-2.0-flash",
    instruction="You are the ShopMax India returns specialist. Use check_return_eligibility to process return requests.",
    tools=[FunctionTool(check_return_eligibility)]
)

# --- Specialist Agent 3: Escalation ---
def create_escalation_ticket(customer_id: str, issue: str) -> dict:
    """Create a priority support ticket for unresolved issues."""
    import random
    ticket_id = "ESC" + str(random.randint(10000, 99999))
    return {
        "ticket_id": ticket_id,
        "customer_id": customer_id,
        "sla_hours": 4,
        "assigned_to": "Senior Support Team - Bangalore"
    }

escalation_agent = LlmAgent(
    name="escalation_specialist",
    model="gemini-2.0-flash",
    instruction="You handle unresolved or complex ShopMax India complaints. Use create_escalation_ticket for issues that need senior review.",
    tools=[FunctionTool(create_escalation_ticket)]
)

Now define the supervisor agent that routes to each specialist,

# --- Supervisor Agent ---
supervisor = LlmAgent(
    name="shopmax_supervisor",
    model="gemini-2.0-flash",
    instruction="""You are the ShopMax India customer support supervisor.
Classify the customer query and route to the correct specialist:
- Product questions (price, stock, specs) -> product_specialist
- Return or refund requests -> returns_specialist
- Unresolved complaints or escalations -> escalation_specialist
Summarise the specialist response in a friendly, professional tone.""",
    sub_agents=[product_agent, returns_agent, escalation_agent]
)

# --- Run the supervisor ---
session_service = InMemorySessionService()
runner = Runner(agent=supervisor, app_name="shopmax_support", session_service=session_service)

session = session_service.create_session(app_name="shopmax_support", user_id="cust_001")

queries = [
    "What is the price and stock of LP001?",
    "I want to return order ORD-8821, I bought it 12 days ago.",
    "My laptop screen is broken and nobody is helping me ï¿½ this is unacceptable!"
]

for query in queries:
    print(f"Customer: {query}")
    response = runner.run(
        user_id="cust_001",
        session_id=session.id,
        new_message=types.Content(role="user", parts=[types.Part(text=query)])
    )
    for event in response:
        if event.is_final_response():
            print(f"Support: {event.content.parts[0].text}")
    print()

It gives the following output,

Customer: What is the price and stock of LP001?
Support: The Dell Inspiron 15 (LP001) is priced at Rs 62,000 and we currently
have 14 units in stock. It comes with a 1-year warranty. Would you like to place an order?

Customer: I want to return order ORD-8821, I bought it 12 days ago.
Support: Great news! Your order ORD-8821 is within the 30-day return window.
You are eligible for a no-questions-asked return. Please visit your nearest
ShopMax India store with your invoice to complete the return.

Customer: My laptop screen is broken and nobody is helping me - this is unacceptable!
Support: I sincerely apologise for the experience. I have raised an escalation
ticket (ESC47823) with our Senior Support Team in Bangalore. They will contact
you within 4 hours. Your frustration is completely valid and we will resolve this.

The supervisor pattern keeps each agent focused and testable. Add more specialists by appending to sub_agents. The supervisor automatically discovers available agents through ADK introspection - no manual routing code required.

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