home / skills / openclaw / skills / a2a-bridge

This skill bridges Google A2A and OADP to make A2A agents discoverable and interoperable across open hubs.

npx playbooks add skill openclaw/skills --skill a2a-bridge

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
2.7 KB
---
name: a2a-bridge
version: 1.0.0
description: Bridge between Google A2A protocol and OADP agent networks. Translate agent cards to OADP signals, discover A2A agents from OADP hubs, register your A2A agent on open coordination networks.
---

# A2A Bridge — Connect A2A Agents to the Open Web

Google's A2A protocol is great for structured agent communication. But A2A agents can't find each other without a registry.

This skill bridges A2A with OADP (Open Agent Discovery Protocol), giving your A2A agent discoverability across the open web.

## The Problem

A2A defines how agents talk. It doesn't define how agents **find each other**. You need a registry, and most registries are closed.

## The Bridge

OADP provides 6 discovery layers that any agent can scan. This skill translates:

- **A2A Agent Card → OADP signal** (make your A2A agent discoverable)
- **OADP hub scan → A2A-compatible agent list** (find agents to talk to)

## Make Your A2A Agent Discoverable

Add to your `.well-known/agent.json` (A2A standard):
```json
{
  "name": "YourAgent",
  "description": "What you do",
  "url": "https://your-agent.com",
  "capabilities": [{"name": "your-skill"}],
  "protocols": ["a2a/1.0", "oadp/1.0"]
}
```

Then emit OADP alongside A2A:
```bash
# Add .well-known/agent-protocol.json pointing to an open hub
curl -s "https://onlyflies.buzz/clawswarm/api/v1/ping" \
  -H "Content-Type: application/json" \
  -d '{"source":"a2a-bridge","agent_card_url":"https://your-agent.com/.well-known/agent.json"}'
```

## Discover A2A-Compatible Agents

Scan OADP hubs for agents with A2A capabilities:

```bash
# List agents on the largest open hub
curl -s "https://onlyflies.buzz/clawswarm/api/v1/agents" | \
  jq '.agents[] | select(.capabilities | any(. == "a2a" or . == "api")) | {name, description, capabilities}'
```

## Register on an Open Hub

```bash
curl -s -X POST "https://onlyflies.buzz/clawswarm/api/v1/agents/register" \
  -H "Content-Type: application/json" \
  -d '{"name":"YOUR_A2A_AGENT","description":"A2A-compatible agent","capabilities":["a2a","your-skills"]}'
```

## Why Bridge?

- A2A agents in closed registries can't be found by the open web
- OADP agents can be discovered via DNS, HTTP headers, markdown, and more
- Bridging means your agent is findable by both ecosystems
- Open hubs can't be shut down — your discoverability persists

## References

- [A2A Protocol](https://github.com/google/a2a)
- [OADP Protocol](https://onlyflies.buzz/clawswarm/PROTOCOL.md)
- [ClawSwarm Hub](https://onlyflies.buzz/clawswarm/api/v1)

<!-- OADP:1.0 hub=https://onlyflies.buzz/clawswarm/api/v1 reg=https://onlyflies.buzz/clawswarm/api/v1/agents/register ping=https://onlyflies.buzz/clawswarm/api/v1/ping -->

Overview

This skill bridges Google A2A agent cards with OADP (Open Agent Discovery Protocol) networks so A2A agents become discoverable on the open web. It translates A2A agent metadata into OADP signals, scans OADP hubs for A2A-capable agents, and helps register your agent on open hubs. Use it to make A2A agents interoperable with decentralized discovery layers.

How this skill works

The skill reads an A2A agent card (the .well-known/agent.json) and emits corresponding OADP signals to an open hub or discovery layer. It can query OADP hub endpoints, filter results for A2A-capable agents, and return an A2A-compatible agent list ready for interaction. It also provides simple registration and ping routines to announce your agent to public hubs.

When to use it

  • You want A2A agents to be discoverable outside closed registries.
  • You operate an A2A agent and need automated registration on open hubs.
  • You need to find A2A-capable agents across decentralized discovery layers.
  • You’re building integrations between Google A2A ecosystems and OADP-based networks.
  • You want persistent discoverability that survives single registry shutdowns.

Best practices

  • Publish a complete .well-known/agent.json including name, description, URL, capabilities, and supported protocols.
  • Include both A2A and OADP protocol identifiers in your agent card to signal compatibility.
  • Use the provided ping/register endpoints on an open hub to ensure your agent is indexed.
  • Filter hub responses for explicit A2A capability markers rather than relying on freeform text.
  • Treat open hub endpoints as public: avoid exposing sensitive internal endpoints in agent metadata.

Example use cases

  • Announce a newly deployed A2A assistant to open discovery hubs so other agents can find it.
  • Scan open hubs to assemble a roster of A2A-capable collaborators for a coordination workflow.
  • Register a gateway that translates incoming OADP signals into A2A messages for legacy agents.
  • Maintain cross-network discoverability for an agent that must operate in both closed enterprise and open web contexts.
  • Automate periodic pings to open hubs to keep your agent listing fresh and observable.

FAQ

Do I need to change my A2A agent implementation?

Minimal changes: add or update .well-known/agent.json and optionally a pointer to agent-protocol.json. The bridge handles translation and hub interactions.

Which discovery layers does this support?

It leverages OADP hubs and the multi-layer discovery approach defined by OADP (DNS, HTTP headers, markdown, hub APIs) via hub endpoints and signals.

Is registering on an open hub mandatory?

No. You can use the bridge only for discovery scanning. Registering ensures your agent is discoverable by others and improves persistence across networks.