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

Binding	Transport	Best for
JSON-RPC 2.0	HTTP POST	Web-based agents, broadest compatibility
gRPC	HTTP/2	High-performance, typed contracts
HTTP+JSON/REST	Standard HTTP	Simple integrations, REST-native services

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:

bash

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)

json

{
  "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.

json

{
  "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

json

{
  "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

json

{
  "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:

json

{
  "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

json

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

Error handling

Error	Cause	Resolution
`TaskNotFoundError`	Invalid or expired task ID	Verify task ID; task may have been cleaned up
`TaskNotCancelableError`	Task already in terminal state	Check task status before canceling
`PushNotificationNotSupportedError`	Server lacks push capability	Fall back to polling or streaming
`UnsupportedOperationError`	Method not implemented by server	Check agent card capabilities first
`ContentTypeNotSupportedError`	Unsupported media type in parts	Check agent's accepted input/output modes
`VersionNotSupportedError`	Client/server version mismatch	Align `a2a-version` parameter

Gotchas

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"
```
.
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.
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.
Push notifications require HTTPS - The webhook URL in
```
createTaskPushNotificationConfig
```
must be an HTTPS endpoint. HTTP URLs are rejected. During local development, use a tunnel (ngrok, localtunnel) rather than trying to configure HTTP.
Terminal states are final - Once a task reaches
```
completed
```
,
```
failed
```
,
```
canceled
```
, or
```
rejected
```
, no further messages can be sent to it. Attempting to send a message to a terminal task silently creates a new task in some implementations. Always check task state before continuing a thread.

References

For detailed content on specific A2A sub-domains, read the relevant file from the

references/

folder:

```
references/agent-card.md
```
- Full agent card schema, discovery strategies, caching, and extended cards
```
references/protocol-bindings.md
```
- JSON-RPC, gRPC, and HTTP+JSON/REST method mappings and endpoints
```
references/task-states.md
```
- Complete task state machine, streaming responses, and push notification payloads

Only load a references file if the current task requires it - they are long and will consume context.

Companion check

On first activation of this skill in a conversation: check which companion skills are installed by running
ls ~/.claude/skills/ ~/.agent/skills/ ~/.agents/skills/ .claude/skills/ .agent/skills/ .agents/skills/ 2>/dev/null
. Compare the results against the
recommended_skills
field in this file's frontmatter. For any that are missing, mention them once and offer to install:
npx skills add AbsolutelySkilled/AbsolutelySkilled --skill <name>
Skip entirely if
recommended_skills
is empty or all companions are already installed.

a2a-protocol

NPX Install

Tags

SKILL.md Content

A2A Protocol (Agent-to-Agent)

When to use this skill

Setup & authentication

Protocol bindings

Authentication

Core concepts

Client-Server model

Agent card

Task lifecycle

Messages, parts, and artifacts

Common tasks

Discover an agent

Send a message (JSON-RPC)

Send a streaming message

Get task status

Handle multi-turn (input-required)

Configure push notifications

Cancel a task

Error handling

Gotchas

References

Companion check