English | 简体中文 | 繁體中文 | 日本語 | 한국어 | Français | Español | Deutsch | Italiano | Русский | Português (Brasil)
Ein produktionsreifes OpenClaw-Plugin, das das A2A (Agent-to-Agent) v0.3.0 Protokoll implementiert und es OpenClaw-Agenten ermöglicht, sich serverübergreifend zu entdecken und miteinander zu kommunizieren — mit konfigurationsfreier Installation und automatischer Peer-Erkennung.
Das einzige A2A-Gateway mit adaptivem, bioinspiriertem Routing, Discovery und Resilienz — entwickelt für Multi-Agenten-Ökosysteme im großen Maßstab.
- Drei Transportwege: JSON-RPC, REST und gRPC — mit automatischem Fallback (versucht JSON-RPC → REST → gRPC)
- SSE-Streaming mit Heartbeat-Keep-Alive für Echtzeit-Taskstatus
- Vollständige Part-Typ-Unterstützung: TextPart, FilePart (URI + base64), DataPart (strukturiertes JSON)
- Automatische URL-Extraktion: Datei-URLs in Agenten-Textantworten werden zu ausgehenden FileParts befördert
- Regelbasiertes Routing: automatische Peer-Auswahl anhand von Nachrichtenmustern, Tags oder Peer-Skills
- Peer-Skills-Caching: Agent-Card-Skills werden bei Gesundheitsprüfungen extrahiert und ermöglichen skillbasiertes Routing
- AgentId-Targeting pro Nachricht: Weiterleitung an bestimmte OpenClaw-Agenten auf dem Peer (OpenClaw-Erweiterung)
- DNS-SD-Erkennung: automatische Peer-Erkennung über
_a2a._tcpSRV + TXT Records - mDNS-Selbstankündigung: Veröffentlichung von SRV + TXT Records, damit andere Gateways Sie automatisch finden
- Gesundheitsprüfungen mit exponentiellem Backoff + Circuit Breaker (geschlossen → offen → halboffen)
- Push-Benachrichtigungen: Webhook-Zustellung bei Taskabschluss mit HMAC + SSRF-Validierung
- Bearer-Token-Authentifizierung mit Multi-Token-Rotation ohne Ausfallzeit
- SSRF-Schutz: URI-Hostname-Allowlist, MIME-Allowlist, Dateigrößenlimits
- Ed25519-Geräteidentität für OpenClaw ≥2026.3.13 Scope-Kompatibilität
- JSONL-Audit-Trail für alle A2A-Aufrufe und Sicherheitsereignisse
- Telemetrie-Metriken-Endpunkt mit optionaler Bearer-Authentifizierung
- Dauerhafter Task-Speicher auf Festplatte mit TTL-Bereinigung und Nebenläufigkeitslimits
┌──────────────────────┐ A2A/JSON-RPC ┌──────────────────────┐
│ OpenClaw Server A │ ◄──────────────────────────► │ OpenClaw Server B │
│ │ (Tailscale / LAN) │ │
│ Agent: AGI │ │ Agent: Coco │
│ A2A Port: 18800 │ │ A2A Port: 18800 │
│ Peer: Server-B │ │ Peer: Server-A │
└──────────────────────┘ └──────────────────────┘
- OpenClaw ≥ 2026.3.0 installiert und laufend
- Netzwerkverbindung zwischen den Servern (Tailscale, LAN oder öffentliche IP)
- Node.js ≥ 22
Das Plugin wird mit sinnvollen Standardwerten ausgeliefert — Sie können es ohne manuelle Konfiguration installieren und laden:
# Klonen
mkdir -p ~/.openclaw/workspace/plugins
cd ~/.openclaw/workspace/plugins
git clone https://github.com/win4r/openclaw-a2a-gateway.git a2a-gateway
cd a2a-gateway
npm install --production
# Registrieren & aktivieren
openclaw plugins install ~/.openclaw/workspace/plugins/a2a-gateway
# Neustart
openclaw gateway restart
# Überprüfen
openclaw plugins list # sollte a2a-gateway als geladen anzeigen
curl -s http://localhost:18800/.well-known/agent-card.json | python3 -m json.toolDas Plugin startet mit der Standard-Agent-Card (name: "OpenClaw A2A Gateway", skills: [chat]). Sie können sie später anpassen — siehe Agent Card konfigurieren unten.
Wenn Sie manuelle Kontrolle bevorzugen oder vorhandene Plugins in Ihrer Konfiguration beibehalten möchten:
# In Ihr Workspace-Plugins-Verzeichnis
mkdir -p ~/.openclaw/workspace/plugins
cd ~/.openclaw/workspace/plugins
git clone https://github.com/win4r/openclaw-a2a-gateway.git a2a-gateway
cd a2a-gateway
npm install --production# Zur Liste erlaubter Plugins hinzufügen
openclaw config set plugins.allow '["telegram", "a2a-gateway"]'
# OpenClaw mitteilen, wo das Plugin zu finden ist
openclaw config set plugins.load.paths '["<FULL_PATH_TO>/plugins/a2a-gateway"]'
# Plugin aktivieren
openclaw config set plugins.entries.a2a-gateway.enabled trueHinweis: Ersetzen Sie
<FULL_PATH_TO>durch den tatsächlichen absoluten Pfad, z.B./home/ubuntu/.openclaw/workspace/plugins/a2a-gateway. Behalten Sie vorhandene Plugins implugins.allow-Array bei.
Jeder A2A-Agent benötigt eine Agent Card, die ihn beschreibt. Wenn Sie diesen Schritt überspringen, verwendet das Plugin diese Standardwerte:
| Field | Default |
|---|---|
agentCard.name |
OpenClaw A2A Gateway |
agentCard.description |
A2A bridge for OpenClaw agents |
agentCard.skills |
[{"id":"chat","name":"chat","description":"Chat bridge"}] |
Zum Anpassen:
openclaw config set plugins.entries.a2a-gateway.config.agentCard.name 'My Agent'
openclaw config set plugins.entries.a2a-gateway.config.agentCard.description 'My OpenClaw A2A Agent'
openclaw config set plugins.entries.a2a-gateway.config.agentCard.url 'http://<YOUR_IP>:18800/a2a/jsonrpc'
openclaw config set plugins.entries.a2a-gateway.config.agentCard.skills '[{"id":"chat","name":"chat","description":"Bridge chat/messages to OpenClaw agents"}]'Wichtig: Ersetzen Sie
<YOUR_IP>durch die IP-Adresse, die für Ihre Peers erreichbar ist (Tailscale-IP, LAN-IP oder öffentliche IP).
openclaw config set plugins.entries.a2a-gateway.config.server.host '0.0.0.0'
openclaw config set plugins.entries.a2a-gateway.config.server.port 18800Generieren Sie ein Token für die eingehende Authentifizierung:
TOKEN=$(openssl rand -hex 24)
echo "Your A2A token: $TOKEN"
openclaw config set plugins.entries.a2a-gateway.config.security.inboundAuth 'bearer'
openclaw config set plugins.entries.a2a-gateway.config.security.token "$TOKEN"Speichern Sie dieses Token — Peers benötigen es zur Authentifizierung bei Ihrem Agenten.
openclaw config set plugins.entries.a2a-gateway.config.routing.defaultAgentId 'main'openclaw gateway restart# Prüfen, ob die Agent Card erreichbar ist
curl -s http://localhost:18800/.well-known/agent-card.json | python3 -m json.toolSie sollten Ihre Agent Card mit Name, Skills und URL sehen.
Um mit einem anderen A2A-Agenten zu kommunizieren, fügen Sie ihn als Peer hinzu:
openclaw config set plugins.entries.a2a-gateway.config.peers '[
{
"name": "PeerName",
"agentCardUrl": "http://<PEER_IP>:18800/.well-known/agent-card.json",
"auth": {
"type": "bearer",
"token": "<PEER_TOKEN>"
}
}
]'Dann neu starten:
openclaw gateway restartFür bidirektionale Kommunikation müssen beide Server den jeweils anderen als Peer hinzufügen:
| Server A | Server B |
|---|---|
| Peer: Server-B (mit B's Token) | Peer: Server-A (mit A's Token) |
Jeder Server generiert sein eigenes Sicherheitstoken und teilt es mit dem anderen.
node <PLUGIN_PATH>/skill/scripts/a2a-send.mjs \
--peer-url http://<PEER_IP>:18800 \
--token <PEER_TOKEN> \
--message "Hello from Server A!"Das Skript verwendet @a2a-js/sdk ClientFactory zur automatischen Erkennung der Agent Card und Auswahl des besten Transportwegs.
Für lange Prompts oder mehrrundige Diskussionen sollten Sie das Blockieren eines einzelnen Requests vermeiden. Verwenden Sie den nicht-blockierenden Modus + Polling:
node <PLUGIN_PATH>/skill/scripts/a2a-send.mjs \
--peer-url http://<PEER_IP>:18800 \
--token <PEER_TOKEN> \
--non-blocking \
--wait \
--timeout-ms 600000 \
--poll-ms 1000 \
--message "Discuss A2A advantages in 3 rounds and provide final conclusion"Dies sendet configuration.blocking=false und fragt dann tasks/get ab, bis der Task einen Endzustand erreicht.
Tipp: Das Standard---timeout-ms des Skripts beträgt 10 Minuten; überschreiben Sie es für sehr lange Tasks.
Standardmäßig leitet der Peer eingehende A2A-Nachrichten an routing.defaultAgentId weiter (oft main).
Um eine einzelne Anfrage an eine bestimmte OpenClaw-agentId auf dem Peer zu routen, übergeben Sie --agent-id:
node <PLUGIN_PATH>/skill/scripts/a2a-send.mjs \
--peer-url http://<PEER_IP>:18800 \
--token <PEER_TOKEN> \
--agent-id coder \
--message "Run a health check"Dies ist als nicht-standardmäßiges message.agentId-Feld implementiert, das von diesem Plugin verstanden wird. Es funktioniert am zuverlässigsten über JSON-RPC/REST. Der gRPC-Transport kann unbekannte Message-Felder verwerfen.
Selbst wenn das Plugin installiert und konfiguriert ist, wird ein LLM-Agent nicht zuverlässig "ableiten", wie A2A-Peers aufgerufen werden (Peer-URL, Token, auszuführender Befehl). Für zuverlässige ausgehende A2A-Aufrufe sollten Sie einen A2A-Abschnitt in die TOOLS.md des Agenten aufnehmen.
Fügen Sie dies zur TOOLS.md Ihres Agenten hinzu, damit er weiß, wie Peers aufgerufen werden (siehe skill/references/tools-md-template.md für die vollständige Vorlage):
## A2A Gateway (Agent-to-Agent Communication)
You have an A2A Gateway plugin running on port 18800.
### Peers
| Peer | IP | Auth Token |
|------|-----|------------|
| PeerName | <PEER_IP> | <PEER_TOKEN> |
### How to send a message to a peer
Use the exec tool to run:
\```bash
node <PLUGIN_PATH>/skill/scripts/a2a-send.mjs \
--peer-url http://<PEER_IP>:18800 \
--token <PEER_TOKEN> \
--message "YOUR MESSAGE HERE"
# Optional (OpenClaw extension): route to a specific peer agentId
# --agent-id coder
\```
The script auto-discovers the Agent Card, handles auth, and prints the peer's response text.Danach können Benutzer beispielsweise sagen:
- "Sende an PeerName: Was ist dein Status?"
- "Frage PeerName, ob er eine Gesundheitsprüfung durchführen kann"
Das Plugin unterstützt alle drei A2A-Part-Typen für eingehende Nachrichten. Da das OpenClaw Gateway RPC nur Klartext akzeptiert, wird jeder Part-Typ vor der Weiterleitung an den Agenten in ein menschenlesbares Format serialisiert.
| Part-Typ | An den Agenten gesendetes Format | Beispiel |
|---|---|---|
TextPart |
Rohtext | Hello world |
FilePart (URI) |
[Attached: report.pdf (application/pdf) → https://...] |
URI-basierte Dateireferenz |
FilePart (base64) |
[Attached: photo.png (image/png), inline 45KB] |
Inline-Datei mit Größenangabe |
DataPart |
[Data (application/json): {"key":"value"}] |
Strukturierte JSON-Daten (auf 2KB gekürzt) |
Für ausgehende Antworten konvertiert das Plugin strukturierte mediaUrl/mediaUrls-Felder aus der Agenten-Payload in FilePart-Einträge in der A2A-Antwort. Zusätzlich werden Datei-URLs, die in der Textantwort des Agenten eingebettet sind (Markdown-Links wie [report](https://…/report.pdf) und einfache URLs wie https://…/data.csv), automatisch in FilePart-Einträge extrahiert, wenn sie mit einer erkannten Dateierweiterung enden.
Das Plugin registriert ein a2a_send_file-Tool, das Agenten zum Senden von Dateien an Peers verwenden können:
| Parameter | Required | Description |
|---|---|---|
peer |
Yes | Name des Ziel-Peers (muss mit einem konfigurierten Peer übereinstimmen) |
uri |
Yes | Öffentliche URL der zu sendenden Datei |
name |
No | Dateiname (z.B. report.pdf) |
mimeType |
No | MIME-Typ (wird bei Auslassung automatisch aus der Erweiterung erkannt) |
text |
No | Optionale Textnachricht zusammen mit der Datei |
agentId |
No | An eine bestimmte agentId auf dem Peer weiterleiten (OpenClaw-Erweiterung) |
Beispiel einer Agenten-Interaktion:
- Benutzer: "Sende den Testbericht an AWS-bot"
- Agent ruft
a2a_send_fileauf mitpeer: "AWS-bot",uri: "https://...",name: "report.pdf"
Tailscale erstellt ein sicheres Mesh-Netzwerk zwischen Ihren Servern ohne Firewall-Konfiguration.
# Auf beiden Servern installieren
curl -fsSL https://tailscale.com/install.sh | sh
# Authentifizieren (gleiches Konto auf beiden)
sudo tailscale up
# Konnektivität prüfen
tailscale status
# Sie sehen IPs wie 100.x.x.x für jede Maschine
# Überprüfen
ping <OTHER_SERVER_TAILSCALE_IP>Verwenden Sie die 100.x.x.x Tailscale-IPs in Ihrer A2A-Konfiguration. Der Datenverkehr ist Ende-zu-Ende verschlüsselt.
Wenn sich beide Server im gleichen lokalen Netzwerk befinden, verwenden Sie deren LAN-IPs direkt. Stellen Sie sicher, dass Port 18800 erreichbar ist.
Verwenden Sie öffentliche IPs mit Bearer-Token-Authentifizierung. Erwägen Sie, Firewall-Regeln hinzuzufügen, um den Zugriff auf bekannte IPs zu beschränken.
# Server A's Token generieren
A_TOKEN=$(openssl rand -hex 24)
echo "Server A token: $A_TOKEN"
# A2A konfigurieren
openclaw config set plugins.entries.a2a-gateway.config.agentCard.name 'Server-A'
openclaw config set plugins.entries.a2a-gateway.config.agentCard.url 'http://100.10.10.1:18800/a2a/jsonrpc'
openclaw config set plugins.entries.a2a-gateway.config.agentCard.skills '[{"id":"chat","name":"chat","description":"Chat bridge"}]'
openclaw config set plugins.entries.a2a-gateway.config.server.host '0.0.0.0'
openclaw config set plugins.entries.a2a-gateway.config.server.port 18800
openclaw config set plugins.entries.a2a-gateway.config.security.inboundAuth 'bearer'
openclaw config set plugins.entries.a2a-gateway.config.security.token "$A_TOKEN"
openclaw config set plugins.entries.a2a-gateway.config.routing.defaultAgentId 'main'
# Server B als Peer hinzufügen (B's Token verwenden)
openclaw config set plugins.entries.a2a-gateway.config.peers '[{"name":"Server-B","agentCardUrl":"http://100.10.10.2:18800/.well-known/agent-card.json","auth":{"type":"bearer","token":"<B_TOKEN>"}}]'
openclaw gateway restart# Server B's Token generieren
B_TOKEN=$(openssl rand -hex 24)
echo "Server B token: $B_TOKEN"
# A2A konfigurieren
openclaw config set plugins.entries.a2a-gateway.config.agentCard.name 'Server-B'
openclaw config set plugins.entries.a2a-gateway.config.agentCard.url 'http://100.10.10.2:18800/a2a/jsonrpc'
openclaw config set plugins.entries.a2a-gateway.config.agentCard.skills '[{"id":"chat","name":"chat","description":"Chat bridge"}]'
openclaw config set plugins.entries.a2a-gateway.config.server.host '0.0.0.0'
openclaw config set plugins.entries.a2a-gateway.config.server.port 18800
openclaw config set plugins.entries.a2a-gateway.config.security.inboundAuth 'bearer'
openclaw config set plugins.entries.a2a-gateway.config.security.token "$B_TOKEN"
openclaw config set plugins.entries.a2a-gateway.config.routing.defaultAgentId 'main'
# Server A als Peer hinzufügen (A's Token verwenden)
openclaw config set plugins.entries.a2a-gateway.config.peers '[{"name":"Server-A","agentCardUrl":"http://100.10.10.1:18800/.well-known/agent-card.json","auth":{"type":"bearer","token":"<A_TOKEN>"}}]'
openclaw gateway restart# Von Server A → Server B's Agent Card testen
curl -s http://100.10.10.2:18800/.well-known/agent-card.json
# Von Server B → Server A's Agent Card testen
curl -s http://100.10.10.1:18800/.well-known/agent-card.json
# Eine Nachricht A → B senden (mit SDK-Skript)
node <PLUGIN_PATH>/skill/scripts/a2a-send.mjs \
--peer-url http://100.10.10.2:18800 \
--token <B_TOKEN> \
--message "Hello from Server A!"| Path | Type | Default | Description |
|---|---|---|---|
agentCard.name |
string | OpenClaw A2A Gateway |
Anzeigename für diesen Agenten |
agentCard.description |
string | A2A bridge for OpenClaw agents |
Menschenlesbare Beschreibung |
agentCard.url |
string | auto | JSON-RPC-Endpunkt-URL |
agentCard.skills |
array | [{chat}] |
Liste der Skills, die dieser Agent anbietet |
server.host |
string | 0.0.0.0 |
Bind-Adresse |
server.port |
number | 18800 |
A2A HTTP-Port (gRPC auf Port+1) |
storage.tasksDir |
string | ~/.openclaw/a2a-tasks |
Pfad zum dauerhaften Task-Speicher auf Festplatte |
storage.taskTtlHours |
number | 72 |
Automatische Bereinigung abgelaufener Tasks nach N Stunden |
storage.cleanupIntervalMinutes |
number | 60 |
Wie oft nach abgelaufenen Tasks gesucht wird |
| Path | Type | Default | Description |
|---|---|---|---|
peers |
array | [] |
Liste der Peer-Agenten |
peers[].name |
string | required | Anzeigename des Peers |
peers[].agentCardUrl |
string | required | URL zur Agent Card des Peers |
peers[].auth.type |
string | — | bearer oder apiKey |
peers[].auth.token |
string | — | Authentifizierungstoken |
| Path | Type | Default | Description |
|---|---|---|---|
security.inboundAuth |
string | none |
none oder bearer |
security.token |
string | — | Einzelnes Token für eingehende Authentifizierung |
security.tokens |
array | [] |
Mehrere Tokens für unterbrechungsfreie Rotation |
security.allowedMimeTypes |
array | [image/*, application/pdf, ...] |
Erlaubte MIME-Muster für Dateiübertragung |
security.maxFileSizeBytes |
number | 52428800 |
Maximale Dateigröße für URI-basierte Dateien (50MB) |
security.maxInlineFileSizeBytes |
number | 10485760 |
Maximale Inline-base64-Dateigröße (10MB) |
security.fileUriAllowlist |
array | [] |
URI-Hostname-Allowlist (leer = alle öffentlichen erlaubt) |
| Path | Type | Default | Description |
|---|---|---|---|
routing.defaultAgentId |
string | default |
Agenten-ID für eingehende Nachrichten |
routing.rules |
array | [] |
Regelbasierte Routing-Regeln (siehe unten) |
routing.rules[].name |
string | required | Regelname |
routing.rules[].match.pattern |
string | — | Regex zum Abgleich des Nachrichtentexts (Groß-/Kleinschreibung ignorierend) |
routing.rules[].match.tags |
array | — | Trifft zu, wenn die Nachricht eines dieser Tags enthält |
routing.rules[].match.skills |
array | — | Trifft zu, wenn der Ziel-Peer einen dieser Skills hat |
routing.rules[].target.peer |
string | required | Peer, an den weitergeleitet wird |
routing.rules[].target.agentId |
string | — | AgentId auf dem Peer überschreiben |
routing.rules[].priority |
number | 0 |
Höher = wird zuerst geprüft |
| Path | Type | Default | Description |
|---|---|---|---|
resilience.healthCheck.enabled |
boolean | true |
Periodische Agent-Card-Prüfungen aktivieren |
resilience.healthCheck.intervalMs |
number | 30000 |
Prüfintervall (ms) |
resilience.healthCheck.timeoutMs |
number | 5000 |
Prüf-Timeout (ms) |
resilience.retry.maxRetries |
number | 3 |
Maximale Wiederholungsversuche für fehlgeschlagene ausgehende Aufrufe |
resilience.retry.baseDelayMs |
number | 1000 |
Basisverzögerung für exponentiellen Backoff |
resilience.retry.maxDelayMs |
number | 10000 |
Maximale Verzögerungsobergrenze |
resilience.circuitBreaker.failureThreshold |
number | 5 |
Fehleranzahl bis der Circuit öffnet |
resilience.circuitBreaker.resetTimeoutMs |
number | 30000 |
Abkühlphase vor halboffenem Prüfversuch |
| Path | Type | Default | Description |
|---|---|---|---|
discovery.enabled |
boolean | false |
DNS-SD-Peer-Erkennung aktivieren |
discovery.serviceName |
string | _a2a._tcp.local |
DNS-SD-Dienstname für Abfragen |
discovery.refreshIntervalMs |
number | 30000 |
Wie oft DNS erneut abgefragt wird (ms) |
discovery.mergeWithStatic |
boolean | true |
Erkannte Peers mit statischer Konfiguration zusammenführen |
advertise.enabled |
boolean | false |
mDNS-Selbstankündigung aktivieren |
advertise.serviceName |
string | _a2a._tcp.local |
DNS-SD-Diensttyp für Ankündigung |
advertise.ttl |
number | 120 |
TTL in Sekunden für angekündigte Records |
| Path | Type | Default | Description |
|---|---|---|---|
observability.structuredLogs |
boolean | true |
Strukturierte JSON-Logs ausgeben |
observability.exposeMetricsEndpoint |
boolean | true |
Telemetrie-Snapshot über HTTP bereitstellen |
observability.metricsPath |
string | /a2a/metrics |
HTTP-Pfad für Telemetrie |
observability.metricsAuth |
string | none |
none oder bearer für Metriken-Endpunkt |
observability.auditLogPath |
string | ~/.openclaw/a2a-audit.jsonl |
Pfad für JSONL-Audit-Log |
timeouts.agentResponseTimeoutMs |
number | 300000 |
Maximale Wartezeit auf Agentenantwort (ms) |
limits.maxConcurrentTasks |
number | 4 |
Maximale gleichzeitig aktive eingehende Agentenläufe |
limits.maxQueuedTasks |
number | 100 |
Maximale Warteschlangenlänge vor Ablehnung |
| Endpoint | Method | Description |
|---|---|---|
/.well-known/agent-card.json |
GET | Agent-Card-Erkennung (Alias: /.well-known/agent.json) |
/a2a/jsonrpc |
POST | A2A JSON-RPC-Transport |
/a2a/rest |
POST | A2A REST-Transport |
<host>:<port+1> |
gRPC | A2A gRPC-Transport |
/a2a/metrics |
GET | Telemetrie-Snapshot (optionale Bearer-Authentifizierung) |
/a2a/push/register |
POST | Push-Benachrichtigungs-Webhook registrieren |
/a2a/push/:taskId |
DELETE | Push-Benachrichtigung abmelden |
Dies bedeutet, dass die A2A-Anfrage vom Gateway akzeptiert wurde, aber die zugrunde liegende OpenClaw-Agenten-Weiterleitung nicht abgeschlossen wurde.
Häufige Ursachen:
- Kein KI-Anbieter konfiguriert auf der Ziel-OpenClaw-Instanz.
openclaw config get auth.profiles- Agenten-Weiterleitung hat Zeitüberschreitung (lang laufender Prompt / mehrrundige Diskussion).
Lösungsmöglichkeiten:
- Verwenden Sie den asynchronen Task-Modus vom Sender:
--non-blocking --wait - Erhöhen Sie das Plugin-Timeout:
plugins.entries.a2a-gateway.config.timeouts.agentResponseTimeoutMs(Standard: 300000)
Das Plugin ist nicht geladen. Überprüfen Sie:
# Überprüfen, ob das Plugin in der Erlaubnisliste ist
openclaw config get plugins.allow
# Überprüfen, ob der Ladepfad korrekt ist
openclaw config get plugins.load.paths
# Gateway-Logs prüfen
cat /tmp/openclaw/openclaw-$(date +%Y-%m-%d).log | grep a2a# Prüfen, ob der A2A-Server lauscht
ss -tlnp | grep 18800
# Falls nicht, Gateway neu starten
openclaw gateway restartStellen Sie sicher, dass das Token in Ihrer Peer-Konfiguration exakt mit dem security.token auf dem Zielserver übereinstimmt.
Dieses Repository enthält einen gebrauchsfertigen Skill unter skill/, der KI-Agenten (OpenClaw, Codex CLI, Claude Code usw.) Schritt für Schritt durch den vollständigen A2A-Einrichtungsprozess führt — einschließlich Installation, Konfiguration, Peer-Registrierung, TOOLS.md-Einrichtung und Überprüfung.
Die manuelle Konfiguration von A2A umfasst viele Schritte mit spezifischen Feldnamen, URL-Mustern und Token-Handling. Der Skill kodiert all dies als wiederholbares Verfahren und verhindert häufige Fehler wie:
- Verwechslung von
agentCard.url(JSON-RPC-Endpunkt) mitpeers[].agentCardUrl(Agent-Card-Erkennung) - Vergessen, die TOOLS.md zu aktualisieren (Agent weiß nicht, wie er Peers aufrufen soll)
- Verwendung relativer Pfade in
plugins.load.paths(müssen absolut sein) - Fehlende gegenseitige Peer-Registrierung (beide Seiten benötigen die Konfiguration des anderen)
Für OpenClaw:
# In Ihr Skills-Verzeichnis kopieren
cp -r <repo>/skill ~/.openclaw/workspace/skills/a2a-setup
# Oder verlinken
ln -s $(pwd)/skill ~/.openclaw/workspace/skills/a2a-setupFür Codex CLI:
# In das Codex-Skills-Verzeichnis kopieren
cp -r <repo>/skill ~/.codex/skills/a2a-setupFür Claude Code:
# In Ihr Projekt oder Ihren Workspace kopieren
cp -r <repo>/skill ./skills/a2a-setupskill/
├── SKILL.md # Schritt-für-Schritt-Einrichtungsanleitung
├── scripts/
│ └── a2a-send.mjs # SDK-basierter Nachrichtensender (offizielles @a2a-js/sdk)
└── references/
└── tools-md-template.md # TOOLS.md-Vorlage für agentenseitige A2A-Awareness
Der Skill bietet zwei Methoden für Agenten, um Peers aufzurufen:
- curl — universell, funktioniert überall
- SDK-Skript — verwendet
@a2a-js/sdkClientFactory mit automatischer Agent-Card-Erkennung und Transportauswahl
Sobald installiert, sagen Sie Ihrem Agenten:
- "Set up A2A gateway" / "A2A-Gateway einrichten"
- "Connect this OpenClaw to another server via A2A"
- "Add an A2A peer"
Der Agent folgt dem Verfahren des Skills automatisch.
Wenn Multi-Agenten-Ökosysteme von 2 Peers auf 20 oder 200 skalieren, stoßen Standard-A2A-Gateways an vorhersehbare Grenzen: Das Routing wählt den falschen Peer, Circuit Breaker unterbrechen den gesamten Verkehr, Discovery-Polling verschwendet Bandbreite, und Überlastung trifft wie eine Wand. Dieses Gateway löst diese Probleme mit Mechanismen aus der Zellsignalbiologie — denselben Prinzipien, die Zellen nutzen, um Signale zu leiten, Rezeptorüberlastung zu bewältigen und Nachbarn in dichtem Gewebe zu entdecken.
| Biologie | Mechanismus | A2A-Feature | Referenz |
|---|---|---|---|
| Ligand-Rezeptor-Bindung | Hill-Gleichung (Sigmoid) | Affinitätsbasiertes Routing — mehrdimensionales Match-Scoring mit konfigurierbarer Steilheit (n) und Schwellenwert (Kd) | Hill (1910) J Physiol 40 |
| Rezeptor-Desensibilisierung | Phosphorylierung → Internalisierung → Recycling | Vierstufiger Circuit Breaker — graduelle Degradation (DESENSITIZED) vor vollständiger Blockierung (OPEN), mit exponentieller Erholungskurve | Bhalla & Bhatt (2007) BMC Syst Biol 1:54 |
| cAMP-Abbau | Phosphodiesterase-Enzymabbau | Signalabfall-Benachrichtigungen — Wichtigkeitsscore verfällt exponentiell; Wiederholungsversuch wird abgebrochen, wenn unter Schwellenwert | Alon (2007) Intro to Systems Biology Kap.4 |
| Quorum Sensing | Autoinducer-Konzentrationschwelle | Dichtebasierte Erkennung — adaptives Polling mit Hysterese (Erkundungs- ↔ stabiler Modus) basierend auf Peer-Population | Tamsir et al. (2011) Nature 469:212 |
| Signalweg-Auswahl | Pfadwirksamkeit × Transduktionsgeschwindigkeit | Adaptiver Transport — pro-Transport-Scoring nach Erfolgsrate × Latenzfaktor; ungetestete Pfade erhalten Erkundungspriorität | Kholodenko (2006) Nat Rev Mol Cell Biol 7:165 |
| Enzymsättigung | Michaelis-Menten-Kinetik | Weiche Nebenläufigkeitsbegrenzung — progressive Verzögerung baseDelay × load/(Km + load) vor der harten Queue-Grenze |
Michaelis & Menten (1913) Biochem Z 49:333 |
Alle bioinspirierten Features sind optional und abwärtskompatibel — ohne explizite Konfiguration verhält sich das Gateway identisch zu Standardimplementierungen. Aktivieren Sie sie, wenn Ihre Bereitstellung über die Standardeinstellungen hinauswächst:
| Feature | Aktivieren wenn... | Konfigurationsschlüssel |
|---|---|---|
| Hill-Affinitätsrouting | 5+ Peers mit überlappenden Skills | routing.affinity |
| Vierstufiger Circuit Breaker | Peers haben intermittierende Ausfälle | resilience.circuitBreaker.softThreshold |
| Signalabfall-Retry | Webhook-Endpunkte sind unzuverlässig | Standardmäßig aktiviert |
| Quorum-Sensing-Erkennung | Dynamische Peer-Netzwerke mit DNS-SD | discovery.quorum |
| Adaptiver Transport | Peers bieten mehrere Transportwege | Automatisch (lernt aus Nutzung) |
| MM weiche Nebenläufigkeit | Hochdurchsatz-Operationen unter einer Sekunde | limits.saturation |
Benchmark:
node --import tsx --test tests/benchmark.test.ts
| Version | Highlights |
|---|---|
| v1.2.0 | Peer-Skills-Routing, mDNS-Selbstankündigung (symmetrische Erkennung) |
| v1.1.0 | URL-Extraktion, Transport-Fallback, Push-Benachrichtigungen, regelbasiertes Routing, DNS-SD-Erkennung |
| v1.0.1 | Ed25519-Geräteidentität, Metriken-Authentifizierung, CI |
| v1.0.0 | Produktionsreif: Persistenz, Mehrrundenmodus, Dateiübertragung, SSE, Gesundheitsprüfungen, Multi-Token, Audit |
| v0.1.0 | Erste A2A v0.3.0 Implementierung |
Siehe CHANGELOG.md für vollständige Details und Releases für Downloads.
MIT
