What is the full form of A2A?

A2A stands for Agent2Agent or Agent-to-Agent Protocol, defining how AI agents communicate with each other securely and efficiently.

A2A Protocol Architecture Overview

Comparison between A2A and MCP protocols

A2A Protocol communication workflow

Agent Card Example:

{
  "name": "Currency Converter Agent",
  "description": "Converts between currencies using real-time exchange rates",
  "version": "1.0.0",
  "contact": "support@example.com",
  "endpoints": {
    "tasks": "https://api.example.com/a2a/tasks",
    "stream": "https://api.example.com/a2a/stream"
  },
  "auth": {
    "type": "api_key",
    "in": "header",
    "name": "X-API-Key"
  },
  "capabilities": [
    {
      "id": "convert_currency",
      "name": "Convert Currency",
      "description": "Converts an amount from one currency to another",
      "parameters": {
        "type": "object",
        "properties": {
          "amount": {
            "type": "number",
            "description": "The amount to convert"
          },
          "from": {
            "type": "string",
            "description": "Source currency code (ISO 4217)"
          },
          "to": {
            "type": "string",
            "description": "Target currency code (ISO 4217)"
          }
        },
        "required": ["amount", "from", "to"]
      },
      "returns": {
        "type": "object",
        "properties": {
          "converted_amount": {
            "type": "number"
          },
          "rate": {
            "type": "number"
          },
          "timestamp": {
            "type": "string",
            "format": "date-time"
          }
        }
      }
    }
  ]
}

Task lifecycle in the A2A protocol

1. Set up development environment

   Install the A2A SDK for your preferred language:

   # Python
   pip install google-a2a
   
   # JavaScript
   npm install @google/a2a-sdk

2. Create an Agent Card

   Define your agent's capabilities in a JSON file following the A2A specification.

3. Implement API endpoints

   Create the necessary endpoints for task submission, status checking, and streaming.

4. Test integration

   Use the A2A test suite to verify your implementation.

from google_a2a import A2AServer, AgentCard, Task, TaskStatus
from fastapi import FastAPI, HTTPException
import uvicorn
import requests

app = FastAPI()
a2a_server = A2AServer(app)

# Define agent card
agent_card = AgentCard(
    name="Currency Converter",
    description="Converts between currencies using real-time exchange rates",
    version="1.0.0",
    capabilities=[
        {
            "id": "convert_currency",
            "name": "Convert Currency",
            "description": "Converts an amount from one currency to another",
            "parameters": {
                "type": "object",
                "properties": {
                    "amount": {"type": "number"},
                    "from": {"type": "string"},
                    "to": {"type": "string"}
                },
                "required": ["amount", "from", "to"]
            }
        }
    ]
)

# Register agent card
a2a_server.register_agent_card(agent_card)

# Implement task handler
@a2a_server.task_handler("convert_currency")
async def convert_currency(task: Task):
    params = task.parameters
    amount = params.get("amount")
    from_currency = params.get("from")
    to_currency = params.get("to")

    # Update task status to working
    await task.update_status(TaskStatus.WORKING)

    try:
        # Call external API for exchange rates (for example)
        response = requests.get(
            f"https://api.exchangerate-api.com/v4/latest/{from_currency}"
        )
        data = response.json()
        rate = data["rates"].get(to_currency)

        if not rate:
            raise ValueError(f"Exchange rate not found for {to_currency}")

        converted_amount = amount * rate

        # Complete task with result
        await task.complete({
            "converted_amount": converted_amount,
            "rate": rate,
            "timestamp": data["time_last_updated"]
        })

    except Exception as e:
        # Handle errors
        await task.fail(str(e))

if __name__ == "__main__":
    uvicorn.run("app:app", host="0.0.0.0", port=8000)

const express = require('express');
const { A2AServer, TaskStatus } = require('@google/a2a-sdk');
const axios = require('axios');

const app = express();
const port = 8000;

// Initialize A2A server
const a2aServer = new A2AServer({
  name: "Currency Converter",
  description: "Converts between currencies using real-time exchange rates",
  version: "1.0.0",
  capabilities: [
    {
      id: "convert_currency",
      name: "Convert Currency",
      description: "Converts an amount from one currency to another",
      parameters: {
        type: "object",
        properties: {
          amount: { type: "number" },
          from: { type: "string" },
          to: { type: "string" }
        },
        required: ["amount", "from", "to"]
      }
    }
  ]
});

// Register the A2A server with Express
a2aServer.registerExpress(app);

// Implement task handler
a2aServer.registerTaskHandler("convert_currency", async (task) => {
  const { amount, from, to } = task.parameters;

  // Update task status to working
  await task.updateStatus(TaskStatus.WORKING);

  try {
    // Call external API for exchange rates
    const response = await axios.get(
      \`https://api.exchangerate-api.com/v4/latest/\${from}\`
    );
    const data = response.data;
    const rate = data.rates[to];

    if (!rate) {
      throw new Error(\`Exchange rate not found for \${to}\`);
    }

    const convertedAmount = amount * rate;

    // Complete task with result
    await task.complete({
      converted_amount: convertedAmount,
      rate: rate,
      timestamp: data.time_last_updated
    });
  } catch (error) {
    // Handle errors
    await task.fail(error.message);
  }
});

// Start the server
app.listen(port, () => {
  console.log(\`Currency Converter agent listening on port \${port}\`);
});

Error Response Format

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32602,
    "message": "Invalid parameters",
    "data": {
      "details": "Currency code 'XYZ' is not valid"
    }
  },
  "id": "req-123"
}

Multi-agent workflow for customer service use case

Implementation Steps

1. Deploy specialized agents for different aspects of customer service
2. Configure Agent Cards to expose each agent's capabilities
3. Implement a coordinator agent that directs customer queries to appropriate specialists
4. Use A2A for secure communication between coordinator and specialists
5. Aggregate responses and maintain context across the conversation

Submit Feedback

Help improve A2A by sharing your experiences, challenges, and suggestions with the development team.

Stay Updated

Subscribe to receive notifications about A2A updates, new features, and community events.