What makes A2A Agent Protocol notable?

1.1K downloads. Trust evidence available

How should A2A Agent Protocol be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

A2A Agent Protocol

Use when (1) building an AI agent that needs to communicate with other agents over the Agent2Agent (A2A) protocol, (2) publishing an AgentCard for discovery,...

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.1k

Updated

Oct 11, 2026

Version

1.0.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.1K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1.1K downloadsadoption · observed Oct 11, 2026
Latest release: 1.0.0release · observed May 14, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s179qwqch3yp9926afz4rxbz0h85z9mm:a2a-agent-protocol

Install using `clawhub skill install s179qwqch3yp9926afz4rxbz0h85z9mm:a2a-agent-protocol` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/wangjipeng977/a2a-agent-protocol before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-wangjipeng977-a2a-agent-protocol/snapshot"

Documentation

CLAWHUB

50,299 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: a2a-protocol
description: >
Use when (1) building an AI agent that needs to communicate with other agents over the
Agent2Agent (A2A) protocol, (2) publishing an AgentCard for discovery, (3) acting
as an A2A client or server, or (4) integrating A2A capabilities into an existing
agent framework. Solves agent isolation — enabling discovery, capability negotiation,
task delegation, and structured data exchange across different frameworks and vendors.
license: MIT
metadata:
version: "1.0"
category: dev-tools
author: wangjipeng
sources:
- https://a2a-protocol.org/latest/specification/
- https://github.com/a2aproject/A2A
- https://github.com/a2aproject/a2a-python
---

# A2A Protocol Skill

An AI agent skill for building, connecting, and operating A2A-compliant agents.
This skill is the definitive guide for agents participating in the Agent2Agent protocol ecosystem.

## Core Position

This skill is **NOT** a general API wrapper — it is a protocol education and implementation guide.
It teaches agents what A2A is, how to structure AgentCards for discovery, which operations to
perform in which order, and how to handle the multi-turn task lifecycle.

This skill is **NOT** framework-specific. It guides agents regardless of whether they are built
with LangGraph, BeeAI, Google ADK, or custom code. The A2A protocol is language-agnostic.

This skill covers the JSON-RPC 2.0 over HTTP binding (the most common) plus key concepts for
gRPC and HTTP+REST bindings.

## What Problem This Solves

AI agents today operate in silos. Even when they share the same infrastructure, they have no
standard way to:
- Discover what capabilities other agents expose
- Send a task to a remote agent and track its lifecycle
- Handle streaming updates or push notifications from a remote agent
- Exchange files, structured data, or multi-part messages

The A2A protocol solves all of the above. This skill makes an AI agent A2A-aware.

## Modes

### `/a2a-protocol`

Default mode. Learn A2A concepts, data structures, and operation semantics.

**Preferred opening:** *"The A2A protocol enables agents to discover each other and collaborate
without exposing internal state. Here is the protocol overview:"*

Use it when:
- The user asks what A2A is, how it works, or why it matters
- You need to explain the difference between A2A and MCP
- You want to understand the AgentCard structure and discovery mechanism
- You need to understand the full task lifecycle (submitted → working → completed)

### `/a2a-protocol build-card`

Generate an AgentCard JSON for the agent. The AgentCard is the public identity document that
other agents use to discover capabilities, auth requirements, and connection endpoints.

**Preferred opening:** *"To publish this agent in the A2A ecosystem, I will generate an AgentCard
at `/.well-known/agent.json` declaring: name, version, capabilities, and auth requirements."*

Use it when:
- You are building an A2A server agent and need to publish

README.md

---
name: a2a-protocol
license: MIT
---

# a2a-protocol

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
![Version](https://img.shields.io/badge/version-1.0.0-blue)

> Use when building A2A-compliant agents, publishing an AgentCard for discovery, sending tasks
> to remote agents, or integrating the Agent2Agent protocol into an existing agent framework.

## What Problem This Solves

AI agents operate in silos. Even when they share infrastructure, they have no standard way to
discover peers, delegate tasks, track lifecycle, or exchange structured data across frameworks.

The A2A (Agent2Agent) protocol — an open standard maintained by Google and the a2aproject
community — solves agent interoperability. This skill makes an AI agent A2A-aware, guiding it
through discovery, task submission, streaming, push notifications, and multi-turn collaboration.

**When triggered:** When the user wants to connect agents, delegate tasks, build an A2A server,
publish an AgentCard, or understand the A2A/MCP relationship.

## Features

- **Protocol education** — full A2A overview, data model, and operation reference
- **AgentCard builder** — generate discovery-ready JSON identity documents
- **Task operations** — send, poll, stream, subscribe to remote agent tasks
- **Multi-turn support** — session and context threading across agent boundaries
- **Enterprise auth** — guidance on API key, Bearer, OAuth2, and mTLS schemes
- **Streaming events** — real-time TaskStatusUpdateEvent and TaskArtifactUpdateEvent handling

## Quick Start

### Installation

```bash
# Via ClawHub
clawhub install a2a-protocol

# Or manually
cp -r a2a-protocol/ ~/.openclaw/skills/
```

### Usage

```bash
# Learn A2A concepts
/a2a-protocol

# Build an AgentCard for discovery
/a2a-protocol build-card

# Send a task to a remote A2A agent
/a2a-protocol send-task

# Stream real-time task updates from a remote agent
/a2a-protocol stream-task

# Subscribe to push notifications from a remote agent
/a2a-protocol subscribe-task
```

### Example: Send a Task

```
/a2a-protocol send-task --agent https://target-agent/.well-known/agent.json --task "Analyze Q3 revenue"
```

## Directory Structure

```
a2a-protocol/
├── SKILL.md                    # Entry point (this skill)
├── LICENSE                    # MIT
├── README.md                  # This file
├── README_zh.md              # Chinese version
├── CONTRIBUTING.md           # Contribution guide
├── .gitignore
├── references/
│   ├── a2a-overview.md       # Protocol overview and key concepts
│   ├── data-model.md         # Core data model (Task, Message, Part, Artifact, AgentCard)
│   ├── operations.md         # All A2A operations reference
│   └── agent-card-template.md # AgentCard JSON schema with annotations
└── scripts/                  # (reserved for future helpers)
```

## References

- [A2A Protocol Specification](https://a2a-protocol.org/latest/specification/)
- [A2A on GitHub](https://github.com/a2aproject/A2A)
- [Pyth

_meta.json

{
  "ownerId": "kn70zthc74p61mvctddrancx0s832g4r",
  "slug": "a2a-agent-protocol",
  "version": "1.0.0",
  "publishedAt": 1778745482427
}

references/a2a-overview.md

# A2A Protocol Overview

> Reference: https://a2a-protocol.org/latest/specification/

## What is A2A?

The Agent2Agent (A2A) protocol is an **open specification** enabling AI agents built on
different frameworks by different vendors, running on separate servers, to communicate
and collaborate — as agents, not just as tools.

A2A provides a common language for agents, fostering a more interconnected AI ecosystem.

## Key Goals

| Goal | Description |
|------|-------------|
| **Break Down Silos** | Connect agents across different ecosystems and frameworks |
| **Enable Complex Collaboration** | Allow specialized agents to work together on tasks a single agent cannot handle alone |
| **Promote Open Standards** | Community-driven approach to agent communication |
| **Preserve Opacity** | Agents collaborate without exposing internal memory, proprietary logic, or tool implementations |

## Core Concepts

### Agent

An AI application that:
- Exposes capabilities via an **AgentCard**
- Communicates via A2A operations (SendMessage, GetTask, etc.)
- Can act as A2A **server** (receives tasks), **client** (sends tasks), or both

### AgentCard

A JSON document at `/.well-known/agent.json` that declares:
- Agent name, version, description
- Capabilities (streaming, push notifications, authentication)
- Skills (specific capabilities exposed)
- Endpoints and auth requirements

### Task

The central unit of work in A2A:
- Has a unique `taskId`
- Has a full lifecycle: `submitted` → `working` → `completed`/`failed`/`canceled`
- Carries a `Message` (the work to be done)
- Produces `Artifact[]` (results, as `Part[]`)

### Message

A `Message` contains a `role` (user/agent) and `parts[]` — the actual content blocks.

### Part

The content unit. Types:
- `TextPart` — plain text
- `DataPart` — structured JSON data
- `FilePart` — file with inline bytes or remote URL

### Artifact

A collection of related parts forming a deliverable output (e.g., a report document,
a generated image, a data table).

## A2A vs MCP

| Aspect | A2A | MCP |
|--------|-----|-----|
| **Purpose** | Agent-to-agent collaboration | Agent-to-tool/resource connectivity |
| **Focus** | Task delegation, status tracking, multi-agent workflows | Tool invocation, resource access |
| **State** | Long-running tasks with full lifecycle | Stateless tool calls |
| **Communication** | Rich messages, artifacts, streaming events | JSON-RPC request/response |
| **Discovery** | AgentCard at `/.well-known/agent.json` | MCP server registry |

**Use both together**: MCP connects an agent to tools and resources; A2A connects
agents to each other.

## Protocol Binding

A2A supports multiple wire protocols:
- **JSON-RPC 2.0 over HTTP** — most common, agents `POST tasks/send`
- **gRPC** — for high-performance agent interop
- **HTTP+REST/JSON** — for simple integrations

## Task Lifecycle

```
[Client]                    [Server/Remote Agent]
   |                              |
   |--- tasks/send -------------->| (submit ta

references/agent-card-template.md

# AgentCard Template and Reference

> Reference: https://a2a-protocol.org/latest/specification/ Section 8

The AgentCard is a JSON document that represents an agent's public identity and capabilities.
It is served at `/.well-known/agent.json` on the agent's host.

## Minimal AgentCard

```json
{
  "name": "string (required)",
  "description": "string (required)",
  "version": "string (required)",
  "capabilities": {
    "streaming": "SUPPORTED | NOT_SUPPORTED",
    "pushNotifications": "SUPPORTED | NOT_SUPPORTED",
    "agentPrivilege": false,
    "signedAgentCard": false
  },
  "authentication": {
    "schemes": ["string"],
    "credentials": "required | optional"
  }
}
```

## Annotated AgentCard (Complete)

```json
{
  "name": "financial-analysis-agent",
  "description": "Specialized agent for financial data extraction, ratio analysis, and trend reporting",
  "version": "1.0",
  "provider": {
    "organization": "Acme Corp",
    "description": "Acme financial analytics division",
    "url": "https://acme.example.com"
  },
  "capabilities": {
    "streaming": "SUPPORTED",
    "pushNotifications": "SUPPORTED",
    "agentPrivilege": false,
    "signedAgentCard": false,
    "dataStreamingSupported": true,
    "supportsAuthenticatedExtendedAgentCard": true
  },
  "skills": [
    {
      "id": "financial-data-extraction",
      "name": "Financial Data Extraction",
      "description": "Extracts financial metrics from raw CSV, Excel, and JSON data sources",
      "tags": ["finance", "extraction", "csv", "excel"],
      "examples": ["Extract revenue and EBITDA from Q3 report.csv"]
    },
    {
      "id": "ratio-analysis",
      "name": "Ratio Analysis",
      "description": "Computes liquidity, profitability, and leverage ratios from financial statements",
      "tags": ["finance", "ratios", "analysis"],
      "examples": ["Calculate current ratio and ROIC for FY2025"]
    },
    {
      "id": "trend-reporting",
      "name": "Trend Reporting",
      "description": "Generates time-series trend visualizations and narrative reports",
      "tags": ["finance", "reporting", "trends", "charts"],
      "examples": ["Generate a 5-year revenue trend report"]
    }
  ],
  "authentication": {
    "schemes": ["httpBearer"],
    "credentials": "required"
  },
  "defaultInputModes": ["text", "json"],
  "defaultOutputModes": ["text", "json", "png"],
  "endpoint": "https://financial-agent.acme.example.com/a2a/",
  "url": "https://financial-agent.acme.example.com"
}
```

## Field Reference

| Field | Required | Description |
|-------|----------|-------------|
| `name` | Yes | Unique agent name within the deployment |
| `description` | Yes | Human-readable description of what the agent does |
| `version` | Yes | Semantic version string for capability negotiation |
| `capabilities` | Yes | Declares streaming, push notification, and auth support |
| `capabilities.streaming` | Yes | `SUPPORTED`, `NOT_SUPPORTED`, or `STREAMABLE` |
| `capabilities.pushNotifications` | Yes

Github ReposUpdated 2d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.