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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Agent2Agent Protocol - A2A

Agent2Agent Protocol - A2A

Author: Venkata Sudhakar

Agent2Agent (A2A) is an open protocol introduced by Google at Cloud NEXT 2025, now supported by 50-plus enterprise partners including Salesforce, ServiceNow, SAP, and Deloitte. A2A defines a standard HTTP-based interface for agents to discover each other's capabilities (the Agent Card), send tasks, receive streaming responses, and collaborate across frameworks and vendors. Think of it as the REST API standard for agents - just as REST enabled any client to call any server, A2A enables any agent to call any other agent regardless of whether it is built with ADK, LangChain, CrewAI, or a proprietary enterprise system.

An A2A server exposes an Agent Card at /.well-known/agent.json describing its capabilities, skills, and the tasks it accepts. Clients call the agent via POST to /tasks/send or /tasks/sendSubscribe for streaming. ADK agents can act as both A2A servers (exposing themselves to other agents) and A2A clients (calling other agents). This interoperability is the key enterprise value: your billing agent built in ADK can call a tax calculation agent built in LangChain at another team or vendor - no shared framework, no shared infrastructure, just the A2A protocol between them.

The below example builds an A2A server exposing a GST calculation agent, then shows a billing agent acting as an A2A client calling it - demonstrating cross-agent delegation with the standard protocol.

# pip install google-adk a2a-sdk
# A2A SERVER: Expose a GST calculation agent as an A2A service

from a2a.server.apps import A2AStarlette
from a2a.server.request_handlers import DefaultRequestHandler
from a2a.server.agent_execution import AgentExecutor, RequestContext
from a2a.server.tasks import TaskUpdater
from a2a.types import AgentCapabilities, AgentCard, AgentSkill, Message, Part, TextPart
from a2a.types import TaskState
import uvicorn

# The specialist agent - knows GST calculation for India
class GSTCalculatorExecutor(AgentExecutor):
    async def execute(self, context: RequestContext, task_updater: TaskUpdater) -> None:
        user_message = context.get_user_input()
        # Parse amount and GST rate from the message
        lines = user_message.lower()
        amount = 0.0
        rate   = 18.0  # default GST rate
        for word in lines.split():
            try:
                val = float(word.replace("rs", "").replace(",", ""))
                if val > 100:
                    amount = val
                elif val <= 28:
                    rate = val
            except ValueError:
                pass
        if amount == 0:
            reply = "Please provide an amount. Example: Calculate GST on Rs 50000 at 18 percent"
        else:
            gst_amount  = round(amount * rate / 100, 2)
            cgst        = round(gst_amount / 2, 2)
            sgst        = round(gst_amount / 2, 2)
            total       = round(amount + gst_amount, 2)
            reply = (
                "GST Calculation:\n"
                "Base Amount:  Rs " + str(amount) + "\n"
                "GST Rate:     " + str(rate) + " percent\n"
                "CGST (" + str(rate/2) + "%): Rs " + str(cgst) + "\n"
                "SGST (" + str(rate/2) + "%): Rs " + str(sgst) + "\n"
                "Total Amount: Rs " + str(total)
            )
        await task_updater.submit(
            Message(role="agent", parts=[Part(root=TextPart(text=reply))]),
            state=TaskState.completed
        )

async def cancel(self, context: RequestContext, task_updater: TaskUpdater) -> None:
        raise NotImplementedError

# Define the Agent Card - this is what other agents discover
gst_agent_card = AgentCard(
    name="GST Calculator Agent",
    description="Calculates GST breakdown (CGST + SGST) for any transaction amount in India",
    url="http://localhost:8001",
    version="1.0.0",
    capabilities=AgentCapabilities(streaming=False),
    skills=[
        AgentSkill(
            id="gst_calculation",
            name="GST Calculation",
            description="Calculate CGST, SGST and total amount for a given base price and GST rate",
            examples=["Calculate GST on Rs 50000 at 18 percent",
                      "What is the GST on Rs 12500 at 12 percent?"]
        )
    ]
)

# Build and serve the A2A server
handler = DefaultRequestHandler(agent_executor=GSTCalculatorExecutor(),
                                task_store=None)
gst_server = A2AStarlette(agent_card=gst_agent_card, http_handler=handler)

# Run with: uvicorn this_file:gst_server --port 8001
# Or: uvicorn.run(gst_server, host="0.0.0.0", port=8001)
print("GST Calculator A2A server ready at http://localhost:8001")
print("Agent Card: http://localhost:8001/.well-known/agent.json")

Building the A2A client - billing agent calling the GST agent across the A2A protocol,

# A2A CLIENT: ADK billing agent calling the GST Calculator agent
import asyncio
from a2a.client import A2AClient
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types as genai_types

async def call_gst_agent(query: str) -> str:
    # A2A client connects to the GST Calculator agent
    async with A2AClient(url="http://localhost:8001") as client:
        # Discover what the agent can do
        card = await client.get_agent_card()
        print("Connected to A2A agent:", card.name)
        # Send a task
        result = await client.send_task(
            message=query,
            session_id="billing-session-1"
        )
        return result.result.history[-1].parts[0].root.text

def calculate_gst_via_a2a(amount_description: str) -> dict:
    # Wrapper to call async A2A client from sync ADK tool
    result = asyncio.run(call_gst_agent(amount_description))
    return {"gst_calculation": result, "source": "GST Calculator Agent via A2A"}

# ADK billing agent uses the A2A-connected GST tool
billing_agent = Agent(
    model="gemini-2.0-flash",
    name="billing_agent",
    instruction=(
        "You are a billing assistant for ShopMax India. "
        "When customers need GST calculations, use calculate_gst_via_a2a. "
        "Format invoice totals clearly with itemised GST breakdown."
    ),
    tools=[calculate_gst_via_a2a]
)

sessions = InMemorySessionService()
runner   = Runner(agent=billing_agent, app_name="billing", session_service=sessions)

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

print(ask("Create an invoice: product Rs 45000, service Rs 12000. Both attract 18% GST."))

It gives the following output showing cross-agent A2A delegation,

Connected to A2A agent: GST Calculator Agent

SHOPMAX INDIA - INVOICE

Product (Base):  Rs 45,000
  CGST 9%:       Rs 4,050
  SGST 9%:       Rs 4,050
  Product Total: Rs 53,100

Service (Base):  Rs 12,000
  CGST 9%:       Rs 1,080
  SGST 9%:       Rs 1,080
  Service Total: Rs 14,160

Grand Total:     Rs 67,260
(Base: Rs 57,000 + GST: Rs 10,260)

# Billing agent (ADK) called GST Calculator agent (A2A server)
# Two agents, potentially different frameworks, same protocol
# GST agent can be called by ANY A2A client - ADK, LangChain, CrewAI, or enterprise ERP
# Replace the GST agent URL to swap implementations without changing billing agent code

A2A is the agent equivalent of REST APIs - it decouples agent consumers from agent providers. Your billing agent does not need to know how the GST agent is implemented; it just calls a URL and gets a response. This is transformative for enterprise architectures: different teams can build and maintain specialist agents independently, expose them via A2A, and compose them into complex workflows without any shared codebase or framework lock-in. As the A2A ecosystem grows (50-plus partners including SAP, Salesforce, and ServiceNow), your ADK agents will be able to delegate to enterprise-grade specialist agents from these vendors via the same standard protocol.

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