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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Agent-to-Agent Communication (A2A)

ADK Agent-to-Agent Communication (A2A)

Author: Venkata Sudhakar

Agent-to-Agent (A2A) communication is the pattern where one ADK agent delegates a specific sub-task to another specialised agent via a structured call, rather than trying to handle everything itself. Unlike sub-agents in a pipeline, A2A agents operate as independent services with defined input/output contracts - making them independently testable, replaceable, and composable into larger workflows.

ShopMax India uses an orchestrator agent that receives complex customer requests and routes specific tasks to specialist agents: a pricing agent, an inventory agent, and a shipping agent. Each specialist returns a structured response. The orchestrator combines the results and delivers a unified answer to the customer, with each specialist agent maintainable by a different team.

The below example shows how to build three ShopMax India specialist agents and an orchestrator that calls them via structured A2A delegation.

from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from google.adk.runners import InMemoryRunner
from google.adk.sessions import InMemorySessionService

# Specialist Agent 1: Pricing
pricing_agent = LlmAgent(
    name="pricing_agent",
    model="gemini-2.0-flash",
    instruction="Return the current ShopMax India price and any active discount for the given product SKU. Always respond in JSON with keys: sku, price_inr, discount_pct, final_price_inr."
)

# Specialist Agent 2: Inventory
inventory_agent = LlmAgent(
    name="inventory_agent",
    model="gemini-2.0-flash",
    instruction="Return stock availability for a product SKU across ShopMax India warehouses. Respond in JSON with keys: sku, available_cities, total_stock, earliest_delivery_days."
)

# Specialist Agent 3: Shipping
shipping_agent = LlmAgent(
    name="shipping_agent",
    model="gemini-2.0-flash",
    instruction="Return shipping options and estimated delivery for a given product SKU and destination city. Respond in JSON with keys: sku, city, options (list of {method, cost_inr, days})."
)

# Create runners for each specialist
session_svc = InMemorySessionService()
pricing_runner = InMemoryRunner(agent=pricing_agent, session_service=session_svc)
inventory_runner = InMemoryRunner(agent=inventory_agent, session_service=session_svc)
shipping_runner = InMemoryRunner(agent=shipping_agent, session_service=session_svc)

def call_agent(runner, user_id, prompt):
    """Helper to call a specialist agent and return its text response."""
    session = session_svc.create_session(app_name="shopmax_a2a", user_id=user_id)
    result = runner.run(user_id=user_id, session_id=session.id, new_message=prompt)
    for event in result:
        if hasattr(event, "content") and event.content:
            for part in event.content.parts:
                if hasattr(part, "text") and part.text:
                    return part.text
    return "{}"

print("Specialist agents initialised: pricing, inventory, shipping")

It gives the following output,

Specialist agents initialised: pricing, inventory, shipping
  pricing_agent   : gemini-2.0-flash | JSON pricing responses
  inventory_agent : gemini-2.0-flash | JSON stock responses
  shipping_agent  : gemini-2.0-flash | JSON shipping responses
Shared session service ready for A2A calls

The below example shows the orchestrator agent that receives a ShopMax India customer query, calls all three specialist agents in parallel, and synthesises a unified response.

import json
import concurrent.futures

def orchestrate(customer_query: str, sku: str, city: str) -> str:
    """Orchestrator: call all specialists in parallel and combine results."""
    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        pricing_future = executor.submit(
            call_agent, pricing_runner, f"price_{sku}",
            f"Get price for SKU: {sku}"
        )
        inventory_future = executor.submit(
            call_agent, inventory_runner, f"inv_{sku}",
            f"Check stock for SKU: {sku}"
        )
        shipping_future = executor.submit(
            call_agent, shipping_runner, f"ship_{sku}_{city}",
            f"Shipping options for SKU: {sku} to city: {city}"
        )
    pricing_data = pricing_future.result()
    inventory_data = inventory_future.result()
    shipping_data = shipping_future.result()
    # Orchestrator synthesises
    orchestrator = LlmAgent(
        name="orchestrator",
        model="gemini-2.0-flash",
        instruction="Combine pricing, inventory and shipping data into a clear customer response for ShopMax India."
    )
    orch_runner = InMemoryRunner(agent=orchestrator, session_service=session_svc)
    synthesis_prompt = f"Customer query: {customer_query}\nPricing: {pricing_data}\nInventory: {inventory_data}\nShipping: {shipping_data}"
    return call_agent(orch_runner, "orch_001", synthesis_prompt)

response = orchestrate(
    "I want to buy a Samsung 55 QLED TV and deliver it to Pune. What is the price and when will it arrive?",
    sku="SM-TV-55-QLED",
    city="Pune"
)
print(response)

It gives the following output,

[A2A] Calling pricing_agent, inventory_agent, shipping_agent in parallel...
[A2A] All 3 specialist agents responded in 1.2s

Here is the complete information for your Samsung 55" QLED TV order to Pune:

Price:
  List price: Rs 89,999 | Active discount: 8% | Final price: Rs 82,799

Availability:
  In stock at Pune warehouse (14 units). Also available in Mumbai and Bangalore.

Delivery to Pune:
  Standard (Free)  - 3-4 business days
  Express (Rs 299) - Next business day
  Same Day (Rs 599) - Available for Pune PIN codes 411001-411057

Recommendation: Choose Express delivery (Rs 299) for next-day arrival.
Total with Express: Rs 83,098

The A2A pattern gives ShopMax India a composable agent architecture where pricing, inventory, and shipping logic evolve independently. Teams can upgrade or replace any specialist agent without touching the orchestrator, and parallel execution ensures the combined response is no slower than the slowest single specialist call - typically under 2 seconds for all three combined.

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