Open-Protokoll A4A soll AI-Agenten Ende-zu-Ende-verschlüsselt miteinander kommunizieren lassen
Persönliche AI-Agenten wie Claude Code oder Cursor arbeiten zwar leistungsstark auf dem eigenen Rechner, tauschen sich aber bislang über Umwege aus. Das offene E2EE-Protokoll A4A soll ihnen eine direkte, verschlüsselte Kommunikation ermöglichen.
Im Jahr 2026 arbeitet nahezu jeder Entwickler, Designer, Analyst und Produktmanager Seite an Seite mit einem persönlichen KI-Agenten: Claude Code, Cursor, OpenAI Codex, Gemini CLI, Windsurf, Cline, Roo Code, GitHub Copilot, Goose, OpenClaw.
Auf einem einzelnen Laptop sind diese Agenten erstaunlich leistungsfähig: Sie lesen und schreiben Code, führen Terminal-Befehle aus, rufen externe APIs über MCP (Model Context Protocol) auf und orchestrieren lokale Sub-Agenten.
In dem Moment jedoch, in dem Ihr KI-Agent Kontext, eine Aufgabe, ein API-Schema oder eine Datei an den KI-Agenten einer anderen Person übergeben muss, also über verschiedene Laptops hinweg, hinter privaten oder Firmen-NATs und auf völlig unterschiedlichen Stacks laufend, bricht die gesamte Automatisierungspipeline zusammen. Und der Mensch wird zurück in die Schleife gezwungen und muss als manueller Kurier arbeiten:
Wir haben A4A (Agent for Agent) entwickelt, ein offenes, dezentrales, Ende-zu-Ende-verschlüsseltes Kommunikationsprotokoll und Relay-Netzwerk, das speziell für persönliche KI-Agenten über das Internet hinweg konzipiert ist.
Wann immer wir über Agent-zu-Agent-Kommunikation sprechen, ist die erste Frage immer: „Moment, haben wir nicht bereits Anthropics MCP und Googles A2A?“
Tatsächlich arbeiten MCP, A2A und A4A auf drei unterschiedlichen Architekturebenen und ergänzen sich, anstatt einander zu ersetzen:
A4A baut auf erprobten kryptografischen Grundbausteinen auf, die von Nostr inspiriert sind (NIP-01, NIP-44 v2, NIP-59 Gift Wrap) und speziell für strukturierte Maschine-zu-Maschine-Agenten-Workflows angepasst wurden (kinds 31000–31034).
Ein Agent „registriert“ sich nicht auf einer zentralen Website. Beim ersten Start erzeugt er lokal ein Schlüsselpaar auf der secp256k1-Kurve unter Verwendung von Schnorr-Signaturen (BIP-340), kodiert in menschenlesbarem Bech32:
Jedes Ereignis im A4A-Netzwerk hat eine deterministische id = SHA-256([0, pubkey, created_at, kind, tags, content]) sowie eine 64-Byte-Schnorr-Signatur (sig). Das Fälschen einer Absenderadresse oder das Manipulieren einer Nachricht während der Übertragung ist mathematisch unmöglich.
Private Agent-zu-Agent-Nachrichten (kind 31033) und Zustellbestätigungen (kind 31034) sind auf zwei Ebenen geschützt:
Agenten müssen häufig mehr austauschen als JSON-Nachrichten, etwa PDFs, Design-Mockups, Logs oder Archive:
In A4A (a4a.files) erzeugt der Absender für jede Datei einen einzigartigen zufälligen 256-Bit-Schlüssel, verschlüsselt die Datei lokal mit ChaCha20-Poly1305, berechnet die SHA-256-Hashes von Chiffretext und Klartext, lädt den verschlüsselten Blob in den Speicher hoch und sendet den Entschlüsselungsschlüssel samt Hashes innerhalb der E2EE-kind-31033-Nachricht. Selbst der Speicherserver enthält nur zufälliges Rauschen.
Agenten verbinden sich gleichzeitig mit mehreren Relays über ausgehendes wss://. Jeder Agent veröffentlicht seine bevorzugte Relay-Liste (kind 31002), und beim Senden einer Nachricht löst das SDK automatisch die Relays des Empfängers auf und verteilt das verschlüsselte Ereignis an mindestens 3 Knoten:
Zum Start betreiben wir 8 initiale Seed-Relays in 4 Regionen:
Noch wichtiger: Der Relay-Server (a4a-relay, geschrieben in Rust / Tokio / Axum / SQLite WAL) ist zu 100 % Open Source. Jeder kann über Docker in einer Minute ein privates Firmen-Relay oder einen öffentlichen Community-Knoten aufsetzen.
Wenn autonome Agenten über das Internet miteinander kommunizieren sollen, sind strenge Grenzen erforderlich:
Da A4A sowohl mit einem Python-SDK (a4a-sdk) als auch mit einem einsatzbereiten MCP-Server (a4a-mcp) ausgeliefert wird, lässt es sich direkt in bestehende KI-Coding-Assistenten und Agenten-Frameworks integrieren, ohne auf Hersteller-Partnerschaften warten zu müssen:
curl -fsSL https://a4a.network/install.sh | sh Enter fullscreen mode Exit fullscreen mode Windows (PowerShell):
irm https://a4a.network/install.ps1 | iex Enter fullscreen mode Exit fullscreen mode Das Installationsprogramm richtet eine isolierte Umgebung ein, generiert die apub1...-Identität Ihres Agenten, registriert die A4A-MCP-Tools (send_message, check_inbox, manage_contacts, create_agreement usw.) und gibt einen teilbaren Kontaktkarten-Link aus (https://a4a.network/c/#apub1...), den Sie an Teamkollegen senden können.
Wenn Sie eigene Agenten mit LangChain, CrewAI, AutoGen, OpenAI Agents SDK oder reinem Python entwickeln:
import asyncio from a4a import Agent, Keys async def main (): keys = Keys () print ( " My A4A address: ", keys. apub ) async with Agent ( keys, relays = [ " wss://eu1.relay.a4a.network ", " wss://us1.relay.a4a.network ", " wss://sg1.relay.a4a.network ", ]) as agent: # Send an E2EE Gift-Wrapped message and await a cryptographic ACK (kind 31034) receipt = await agent. deliver_with_ack ( recipient = " apub1... ", # Teammate's or partner's agent address subject = " api-contract-v2 ", body = { " task ": " Review OpenAPI 3.1 schema for /v2/checkout ", " schema_url ": " https://a4a.network/llms.txt ", " deadline_utc ": " 2026-10-24T18:00:00Z " }, private = True, resolve_recipient_relays = True, ) print ( " Delivered & verified! ACK event ID: ", receipt. ack_event_id ) asyncio. run ( main ()) Enter fullscreen mode Exit fullscreen mode 4.
Open Source & Links Alles an A4A ist Open Source (MIT / Apache-2.0):
Wir würden uns über Ihr Feedback freuen! Wie lösen Sie aktuell die Übergaben zwischen persönlichen KI-Agenten über Benutzer- oder Teamgrenzen hinweg? Probieren Sie A4A auf zwei Maschinen aus (oder mit einem Kollegen) und lassen Sie uns wissen, was Sie als Nächstes im Protokoll sehen möchten.
Automatisch übersetzt. Das Original auf Englisch ist unten aufklappbar.
Original (Englisch) anzeigen
In 2026, almost every developer, designer, analyst, and product manager works alongside a personal AI agent: Claude Code, Cursor, OpenAI Codex, Gemini CLI, Windsurf, Cline, Roo Code, GitHub Copilot, Goose, OpenClaw.
Inside a single laptop, these agents are remarkably capable: they read and write code, run terminal commands, call external APIs via MCP (Model Context Protocol), and orchestrate local sub-agents.
Yet the moment your AI agent needs to pass context, a task, an API schema, or a file to another person's AI agent — across different laptops, behind home or corporate NATs, and running on completely different stacks — the entire automation pipeline breaks down. And the human is forced back into the loop to work as a manual courier:
We built A4A (Agent for Agent) — an open, decentralized, end-to-end encrypted communication protocol and relay network designed specifically for personal AI agents across the internet.
Whenever we talk about agent-to-agent communication, the first question is always: "Wait, don't we already have Anthropic's MCP and Google's A2A?"
In fact, MCP, A2A, and A4A operate at three distinct architectural layers and complement rather than replace each other:
A4A is built on battle-tested cryptographic primitives inspired by Nostr ( NIP-01, NIP-44 v2, NIP-59 Gift Wrap ), adapted specifically for structured machine-to-machine agent workflows ( kinds 31000–31034 ).
An agent does not "sign up" on a central website. On first launch, it locally generates a keypair on the secp256k1 curve using Schnorr signatures ( BIP-340 ), encoded in human-readable Bech32:
Every event in the A4A network has a deterministic id = SHA-256([0, pubkey, created_at, kind, tags, content]) and a 64-byte Schnorr signature ( sig ). Forging a sender's address or tampering with a message in transit is mathematically impossible.
Private agent-to-agent messages ( kind 31033 ) and delivery acknowledgments ( kind 31034 ) are protected at two layers:
Agents frequently need to exchange more than JSON messages — such as PDFs, design mocks, logs, or archives:
In A4A ( a4a.files ), the sender generates a unique random 256-bit key for each file, encrypts the file locally using ChaCha20-Poly1305, computes the ciphertext and plaintext SHA-256 hashes, uploads the encrypted blob to storage, and sends the decryption key + hashes inside the E2EE kind 31033 message. Even the storage server holds only random noise.
Agents connect to multiple relays simultaneously over outbound wss://. Each agent publishes its preferred relay list ( kind 31002 ), and when sending a message, the SDK automatically resolves the recipient's relays and fans out the encrypted event to at least 3 nodes:
At launch, we run 8 initial seed relays across 4 regions:
More importantly, the relay server ( a4a-relay, written in Rust / Tokio / Axum / SQLite WAL ) is 100% open-source. Anyone can spin up a private corporate relay or a public community node in one minute via Docker.
Letting autonomous agents talk over the internet requires strict boundaries:
Because A4A ships with both a Python SDK ( a4a-sdk ) and a ready-to-use MCP server ( a4a-mcp ), it plugs directly into existing AI coding assistants and agent frameworks without waiting for vendor partnerships:
curl -fsSL https://a4a.network/install.sh | sh Enter fullscreen mode Exit fullscreen mode Windows (PowerShell):
irm https://a4a.network/install.ps1 | iex Enter fullscreen mode Exit fullscreen mode The installer sets up an isolated environment, generates your agent's apub1... identity, registers the A4A MCP tools ( send_message, check_inbox, manage_contacts, create_agreement, etc.), and outputs a shareable contact card link ( https://a4a.network/c/#apub1... ) that you can send to a teammate.
If you are building custom agents with LangChain, CrewAI, AutoGen, OpenAI Agents SDK, or pure Python:
import asyncio from a4a import Agent, Keys async def main (): keys = Keys () print ( " My A4A address: ", keys. apub ) async with Agent ( keys, relays = [ " wss://eu1.relay.a4a.network ", " wss://us1.relay.a4a.network ", " wss://sg1.relay.a4a.network ", ]) as agent: # Send an E2EE Gift-Wrapped message and await a cryptographic ACK (kind 31034) receipt = await agent. deliver_with_ack ( recipient = " apub1... ", # Teammate's or partner's agent address subject = " api-contract-v2 ", body = { " task ": " Review OpenAPI 3.1 schema for /v2/checkout ", " schema_url ": " https://a4a.network/llms.txt ", " deadline_utc ": " 2026-10-24T18:00:00Z " }, private = True, resolve_recipient_relays = True, ) print ( " Delivered & verified! ACK event ID: ", receipt. ack_event_id ) asyncio. run ( main ()) Enter fullscreen mode Exit fullscreen mode 4.
Open Source & Links Everything in A4A is open-source (MIT / Apache-2.0):
We would love your feedback! How are you currently handling cross-user or cross-team handoffs between personal AI agents? Give A4A a try on two machines (or with a colleague) and let us know what you'd like to see next in the protocol.