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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Parallel Agent Execution

ADK Parallel Agent Execution

Author: Venkata Sudhakar

A ParallelAgent in ADK runs multiple sub-agents simultaneously and waits for all to complete before returning. This is the right pattern for independent tasks that do not depend on each other. For a market research task that previously ran 3 sources sequentially taking 3 minutes, a ParallelAgent completes all three in about 1 minute - the total time is the duration of the slowest agent, not the sum. All parallel agent outputs accumulate in the shared conversation context, making them visible to a synthesiser agent that runs next.

You combine ParallelAgent inside a SequentialAgent for the classic fan-out then fan-in pattern: run N specialist agents in parallel, then pass all their outputs to one synthesiser. This architecture is declarative and easy to extend - adding a fourth research agent requires zero changes to existing agents. ParallelAgent and SequentialAgent can be nested in any combination to build complex pipelines that are still readable and maintainable.

The below example shows a product team researching a wireless earbuds launch: three agents run simultaneously fetching competitor pricing, customer sentiment, and market size data, then a synthesiser produces a concise go/no-go launch brief.

from google.adk.agents import Agent, ParallelAgent, SequentialAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types as genai_types

def get_competitor_pricing(product_category: str) -> dict:
    "Fetch current competitor pricing data for a product category."
    return {
        "competitors": [
            {"brand": "boAt Airdopes 141",    "price_inr": 1299, "rating": 4.1},
            {"brand": "JBL Tune 230NC",       "price_inr": 2999, "rating": 4.3},
            {"brand": "Sony WF-C500",          "price_inr": 3990, "rating": 4.4},
            {"brand": "Samsung Galaxy Buds2", "price_inr": 4999, "rating": 4.2}
        ],
        "market_median_inr": 3149,
        "gap": "No quality option between Rs 2,000 and Rs 3,000"
    }

def get_customer_sentiment(product_category: str) -> dict:
    "Analyse customer review sentiment for a product category."
    return {
        "reviews_analysed": 72000,
        "positive_pct": 71, "negative_pct": 18,
        "top_complaints": ["battery under 4 hours", "connectivity drops", "ear tip fit"],
        "top_praises": ["sound quality for price", "quick charge"],
        "unmet_need": "6 plus hour battery with ANC under Rs 2,500"
    }

def get_market_size(product_category: str) -> dict:
    "Get market size and growth projections for a product category."
    return {
        "india_market_crore": 4200, "yoy_growth_pct": 34,
        "top_channel": "Online - 68 percent of sales",
        "fastest_segment": "Under Rs 2,000 segment - 41 percent growth",
        "projection_2026_crore": 7100
    }

# Three agents run IN PARALLEL
pricing_agent = Agent(
    model="gemini-2.0-flash", name="pricing_researcher",
    instruction=(
        "Call get_competitor_pricing for the requested product. "
        "Summarise in 4 bullet points: price range, market median, and biggest pricing gap."
    ),
    tools=[get_competitor_pricing]
)

sentiment_agent = Agent(
    model="gemini-2.0-flash", name="sentiment_researcher",
    instruction=(
        "Call get_customer_sentiment for the requested product. "
        "Summarise in 4 bullet points: overall sentiment, top 2 pain points, unmet need."
    ),
    tools=[get_customer_sentiment]
)

market_agent = Agent(
    model="gemini-2.0-flash", name="market_researcher",
    instruction=(
        "Call get_market_size for the requested product. "
        "Summarise in 4 bullet points: market size, growth, top channel, 2026 projection."
    ),
    tools=[get_market_size]
)

# Synthesiser runs AFTER all three complete
synthesiser = Agent(
    model="gemini-2.0-flash", name="launch_synthesiser",
    instruction=(
        "All three research reports are above. "
        "Write a 150-word product launch brief: "
        "market opportunity with numbers, target price point based on the gap, "
        "top 2 product features to prioritise based on pain points, "
        "recommended launch channel, and final GO or NO-GO with one-line reason."
    )
)

# Fan-out then fan-in
pipeline = SequentialAgent(
    name="product_launch_research",
    sub_agents=[
        ParallelAgent(name="parallel_research",
                      sub_agents=[pricing_agent, sentiment_agent, market_agent]),
        synthesiser
    ]
)

Running the parallel pipeline with a real product category query,

It gives the following output after all three parallel agents complete,

=== PRODUCT LAUNCH BRIEF (Synthesiser Output) ===
MARKET OPPORTUNITY: India wireless earbuds market is Rs 4,200 crore growing
at 34% YoY, projected to reach Rs 7,100 crore by 2026. The online channel
drives 68% of sales with the under-Rs 2,000 segment growing fastest at 41%.

TARGET PRICE: Rs 2,299 - fills the clear gap between Rs 2,000 and Rs 3,000
where no quality product currently exists.

TOP 2 FEATURES TO BUILD:
1. Battery: 7+ hours (addresses the top complaint of under-4-hour battery)
2. Secure Fit: Sports ear tips with 3 sizes included (top ear tip complaint)

LAUNCH CHANNEL: Online-first (Amazon and Flipkart) given 68% online share.

RECOMMENDATION: GO - clear pricing gap, strong growth market, addressable
customer pain points align with feasible product features.

# 3 parallel agents ran simultaneously - total time ~1 min vs ~3 min sequential
# All 3 research outputs visible to synthesiser in conversation context
# Adding a 4th research agent (e.g. supply chain) requires zero other changes

Parallel agents work best when research or processing tasks are independent - each fetches data from a different source with no dependency on the others. Avoid parallel agents when Stage B needs Stage A output as input (use sequential instead). Measure the real-world speedup by logging timestamps: in production with real API calls the parallel speedup is proportional to the longest single-agent latency versus the sum. For very large parallel batches (10-plus agents), consider the rate limits of your underlying APIs and add concurrency controls to avoid hitting quotas simultaneously.

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