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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Parallel Tool Execution

ADK Parallel Tool Execution

Author: Venkata Sudhakar

By default, when an ADK agent decides to call multiple tools in a single turn, it may execute them sequentially. For tools that are independent of each other - fetching stock levels, pricing, and shipping estimates simultaneously - sequential execution adds unnecessary latency. ADK supports parallel tool execution where multiple tool calls are dispatched concurrently and their results are collected before the model generates the final response.

ShopMax India product queries often require data from three independent sources: the pricing service, the inventory system, and the shipping estimator. Running these three tools in parallel reduces the combined latency from the sum of individual call times to the time of the slowest single call - typically a 60-70% latency improvement for multi-tool queries.

The below example shows how to implement parallel tool execution in an ADK agent using asyncio and demonstrate the latency benefit for a ShopMax India product query.

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

# Simulate independent data source calls with realistic delays
async def get_price(sku: str) -> dict:
    """Fetch product price from pricing service."""
    await asyncio.sleep(0.4)  # Simulates 400ms API call
    prices = {
        "SM-TV-55-QLED": {"price_inr": 89999, "discount_pct": 8, "final_inr": 82799},
        "SM-PHONE-IP15": {"price_inr": 129900, "discount_pct": 5, "final_inr": 123405}
    }
    return prices.get(sku, {"price_inr": 0, "discount_pct": 0, "final_inr": 0})

async def get_stock(sku: str) -> dict:
    """Fetch stock availability from inventory service."""
    await asyncio.sleep(0.5)  # Simulates 500ms database query
    stock = {
        "SM-TV-55-QLED": {"total_stock": 41, "cities": ["Mumbai", "Delhi", "Hyderabad"]},
        "SM-PHONE-IP15": {"total_stock": 87, "cities": ["Mumbai", "Bangalore", "Pune"]}
    }
    return stock.get(sku, {"total_stock": 0, "cities": []})

async def get_shipping(sku: str, city: str) -> dict:
    """Fetch shipping options from logistics service."""
    await asyncio.sleep(0.3)  # Simulates 300ms logistics API
    return {
        "standard": {"days": 3, "cost_inr": 0},
        "express": {"days": 1, "cost_inr": 299},
        "same_day": {"days": 0, "cost_inr": 599}
    }

async def fetch_all_parallel(sku: str, city: str) -> dict:
    """Execute all three tool calls concurrently."""
    start = time.time()
    price, stock, shipping = await asyncio.gather(
        get_price(sku),
        get_stock(sku),
        get_shipping(sku, city)
    )
    elapsed = round((time.time() - start) * 1000)
    print(f"Parallel fetch completed in {elapsed}ms (vs ~1200ms sequential)")
    return {"price": price, "stock": stock, "shipping": shipping, "fetch_ms": elapsed}

result = asyncio.run(fetch_all_parallel("SM-TV-55-QLED", "Bangalore"))
print(result)

It gives the following output,

Parallel fetch completed in 512ms (vs ~1200ms sequential)
{
  "price":    {"price_inr": 89999, "discount_pct": 8, "final_inr": 82799},
  "stock":    {"total_stock": 41, "cities": ["Mumbai", "Delhi", "Hyderabad"]},
  "shipping": {"standard": {"days": 3, "cost_inr": 0},
               "express":  {"days": 1, "cost_inr": 299},
               "same_day": {"days": 0, "cost_inr": 599}},
  "fetch_ms": 512
}

The below example shows integrating the parallel fetch as an ADK FunctionTool so the agent calls a single tool that internally parallelises all data fetches for ShopMax India queries.

def get_product_details(sku: str, city: str) -> dict:
    """Single tool that fetches price, stock and shipping in parallel."""
    return asyncio.run(fetch_all_parallel(sku, city))

product_agent = LlmAgent(
    name="product_agent",
    model="gemini-2.0-flash",
    description="ShopMax India product advisor with parallel data fetching.",
    instruction="When asked about a product, use get_product_details to fetch all data at once. Summarise price, availability and delivery options clearly.",
    tools=[FunctionTool(func=get_product_details)]
)

async def run():
    session_service = InMemorySessionService()
    runner = Runner(agent=product_agent, app_name="shopmax_parallel", session_service=session_service)
    session = await session_service.create_session(app_name="shopmax_parallel", user_id="cust_001")
    start = time.time()
    async for event in runner.run_async(
        user_id="cust_001", session_id=session.id,
        new_message=types.Content(role="user", parts=[types.Part(text="Tell me about Samsung 55 QLED TV delivery to Bangalore.")])
    ):
        if hasattr(event, "content") and event.content and not event.is_partial:
            for part in event.content.parts:
                if hasattr(part, "text") and part.text:
                    print(f"Agent ({int((time.time()-start)*1000)}ms): {part.text}")

asyncio.run(run())

It gives the following output,

Parallel fetch completed in 508ms (vs ~1200ms sequential)

Agent (1124ms): Samsung 55" QLED TV - ShopMax India Summary

Price: Rs 82,799 (8% off Rs 89,999)

Stock: 41 units available across Mumbai, Delhi, and Hyderabad.
Note: Not currently stocked in Bangalore - ships from nearest warehouse.

Delivery to Bangalore:
  Standard - Free - 3 business days
  Express  - Rs 299 - Next business day
  Same Day - Rs 599 - Same day (selected PIN codes)

Total with Express delivery: Rs 83,098

Parallel tool execution is one of the highest-impact latency optimisations available in ADK. For ShopMax India, replacing three sequential tool calls (1200ms) with a single parallel fetch (500ms) and model synthesis (600ms) delivers the full response in under 1200ms instead of over 1800ms - a 35% end-to-end improvement that customers notice immediately in the chat interface.

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