When this skill is activated, always start your first response with the 🧢 emoji.

A2A Protocol (Agent-to-Agent)

A2A is an open protocol for seamless communication and collaboration between AI agents, regardless of their underlying frameworks or vendors. Originally created by Google and now under the Linux Foundation, it enables agents to discover each other via agent cards, exchange messages through JSON-RPC/gRPC/HTTP bindings, and manage long-running tasks with streaming and push notification support. A2A is complementary to MCP - while MCP connects models to tools and data, A2A enables agent-to-agent collaboration where agents remain autonomous entities.

When to use this skill

Trigger this skill when the user:

• Wants to implement an A2A server or client for agent interoperability
• Needs to create or parse an agent card for agent discovery
• Asks about multi-agent communication or agent-to-agent protocols
• Wants to send messages between agents using A2A
• Needs to manage A2A tasks (create, get, list, cancel, subscribe)
• Wants to implement streaming (SSE) for real-time agent updates
• Needs to configure push notification webhooks for async task updates
• Asks about A2A vs MCP or how they complement each other

Do NOT trigger this skill for:

• MCP (Model Context Protocol) tool/data integration without agent-to-agent needs
• General LLM API calls that don't involve inter-agent communication

Setup & authentication

A2A is a protocol specification, not an SDK. Implementations exist in multiple languages. The protocol uses HTTP(S) with three binding options.

Protocol bindings

Authentication

A2A supports these security schemes declared in agent cards:

• API Key (header, query, or cookie)
• HTTP Basic / Bearer token
• OAuth 2.0 (authorization code, client credentials, device code)
• OpenID Connect
• Mutual TLS (mTLS)

Credentials are passed via HTTP headers, separate from protocol messages. The spec strongly recommends dynamic credentials over embedded static secrets.

Core concepts

Client-Server model

A2A defines two roles: A2A Client (sends requests on behalf of a user or orchestrator) and A2A Server (remote agent that processes tasks and returns results). Communication is always client-initiated.

Agent card

A JSON metadata document at /.well-known/agent-card.json declaring an agent's identity, endpoint URL, capabilities (streaming, push notifications), security schemes, and skills. This is how agents discover each other.

Task lifecycle

Tasks are the core work unit. A client sends a message, which may create a task with a unique ID. Tasks progress through states:

submitted -> working -> completed
                    \-> failed
                    \-> canceled
                    \-> input-required (multi-turn)
                    \-> auth-required
                    \-> rejected

Terminal states: completed, failed, canceled, rejected.

Messages, parts, and artifacts

• Message: A single communication turn with role (user/agent) and parts
• Part: Smallest content unit - text, file (raw bytes or URI), or structured JSON data
• Artifact: Named output produced by an agent, composed of parts
• Context: A contextId groups related tasks across interaction turns

Common tasks

Discover an agent

Fetch the agent card from the well-known URI:

curl https://agent.example.com/.well-known/agent-card.json

Three discovery strategies exist: well-known URI (public agents), curated registries (enterprise), and direct configuration (dev/testing).

Send a message (JSON-RPC)

{
  "jsonrpc": "2.0",
  "method": "a2a.sendMessage",
  "id": "req-1",
  "params": {
    "message": {
      "message_id": "msg-001",
      "role": "user",
      "parts": [
        { "text": "Find flights from SFO to JFK on March 20" }
      ]
    },
    "configuration": {
      "accepted_output_modes": ["text/plain"],
      "return_immediately": false
    },
    "a2a-version": "1.0"
  }
}

Response contains either a Task (async) or Message (sync) object.

Send a streaming message

Use a2a.sendStreamingMessage for real-time updates. The server must declare capabilities.streaming: true in its agent card. Returns StreamResponse wrappers containing task updates, messages, or artifact chunks.

{
  "jsonrpc": "2.0",
  "method": "a2a.sendStreamingMessage",
  "id": "req-2",
  "params": {
    "message": {
      "message_id": "msg-002",
      "role": "user",
      "parts": [{ "text": "Summarize this 500-page report" }]
    },
    "a2a-version": "1.0"
  }
}

Get task status

{
  "jsonrpc": "2.0",
  "method": "a2a.getTask",
  "id": "req-3",
  "params": {
    "id": "task-abc-123",
    "history_length": 10,
    "a2a-version": "1.0"
  }
}

history_length: 0 = no history, unset = full history, N = last N messages.

Handle multi-turn (input-required)

When a task enters input-required state, the client sends a follow-up message with the same task_id and context_id:

{
  "jsonrpc": "2.0",
  "method": "a2a.sendMessage",
  "id": "req-4",
  "params": {
    "message": {
      "message_id": "msg-003",
      "task_id": "task-abc-123",
      "context_id": "ctx-xyz",
      "role": "user",
      "parts": [{ "text": "I prefer a morning departure" }]
    },
    "a2a-version": "1.0"
  }
}

Configure push notifications

For long-running tasks, configure webhook callbacks instead of polling:

{
  "jsonrpc": "2.0",
  "method": "a2a.createTaskPushNotificationConfig",
  "id": "req-5",
  "params": {
    "task_id": "task-abc-123",
    "push_notification_config": {
      "url": "https://my-client.example.com/webhook",
      "authentication": {
        "scheme": "bearer",
        "credentials": "webhook-token-here"
      }
    },
    "a2a-version": "1.0"
  }
}

The server sends TaskStatusUpdateEvent and TaskArtifactUpdateEvent payloads to the configured webhook URL.

Cancel a task

{
  "jsonrpc": "2.0",
  "method": "a2a.cancelTask",
  "id": "req-6",
  "params": {
    "id": "task-abc-123",
    "a2a-version": "1.0"
  }
}

Error handling

Gotchas

1. a2a-version in every request - The a2a-version field is required in every JSON-RPC params object. Omitting it causes VersionNotSupportedError even if the server version matches. Always include "a2a-version": "1.0".

2. Streaming requires capability declaration - You cannot call a2a.sendStreamingMessage unless the agent card explicitly declares capabilities.streaming: true. Check the agent card before attempting streaming; fall back to sendMessage otherwise.

3. Task IDs and context IDs are distinct - task_id identifies the specific work unit; context_id groups related tasks across turns. In multi-turn flows, you must pass both. Sending only task_id without the original context_id creates a new context instead of continuing the conversation.

4. Push notifications require HTTPS - The we