Vollständiger Leitfaden zum A2A-Protokoll: Googles quelloffener KI-Agent-Kommunikationsstandard für 2026

Veröffentlichungsdatum: März 2026 · Version: v0.3.0 · Lizenz: Apache 2.0 · Betreuer: Google + Linux Foundation

Im April 2025 hat Google das A2A-Protokoll (Agent2Agent) offiziell quelloffen gemacht — einen offenen Standard zur Lösung des Problems der KI-Agent-Interoperabilität. Mit dem explosionsartigen Wachstum von KI-Agenten im Jahr 2026 wurde die Frage, wie von verschiedenen Frameworks und Unternehmen entwickelte Agenten miteinander kommunizieren und zusammenarbeiten können, zu einer zentralen Herausforderung. Das A2A-Protokoll wurde als „das HTTP des KI-Agenten-Zeitalters” bezeichnet.

Das Hauptziel des A2A-Protokolls ist es, KI-Agenten, die auf verschiedenen Frameworks (wie Google ADK, LangGraph, BeeAI usw.) aufgebaut sind, eine sichere und effiziente Kommunikation und Zusammenarbeit zu ermöglichen, ohne deren interne Zustände, Speicher oder Tool-Implementierungen offenzulegen. Dieses Designkonzept ergänzt das MCP-Protokoll (Model Context Protocol): MCP verbindet Agenten mit externen Tools, A2A verbindet Agenten miteinander.

Warum ist das A2A-Protokoll notwendig?

Das „Turm von Babel”-Problem bei KI-Agenten

Im KI-Ökosystem des Jahres 2026 existieren zahlreiche Agenten-Frameworks und Plattformen:

Google ADK — Googles offizielles Agenten-Entwicklungsframework
LangGraph — LangChains graphbasiertes Agenten-Framework
CrewAI — Multi-Agenten-Framework für Aufgabenorchestrierung
AutoGen — Microsofts quelloffenes Multi-Agenten-Kommunikationsframework
Goose — Blocks quelloffener lokaler Agent
OpenClaw — Schnell wachsende quelloffene Agenten-Plattform

Diese Frameworks arbeiten isoliert, eine direkte Kommunikation zwischen Agenten ist nicht möglich. Stellen Sie sich vor: Sie haben einen LangGraph-Agenten, der auf Datenanalyse spezialisiert ist, und einen CrewAI-Agenten, der Berichte erstellen kann — aber beide können nicht zusammenarbeiten, um die Aufgabe „Daten analysieren und Bericht erstellen” zu erledigen.

Die Lösung von A2A

Das A2A-Protokoll ermöglicht Agenten durch standardisierte Kommunikationsschnittstellen:

Entdeckung gegenseitiger Fähigkeiten — Deklaration von Funktionen durch „Agenten-Karten” (Agent Cards)
Aushandlung von Interaktionsmethoden — Unterstützung von Text, Formularen, Medien und anderen Modalitäten
Sichere Zusammenarbeit bei Langzeitaufgaben — Unterstützung von Streaming- und asynchroner Kommunikation
Wahrung interner Privatsphäre — Keine Notwendigkeit, Speicher, Tools oder proprietäre Logik offenzulegen

A2A vs. MCP: Was ist der Unterschied?

Merkmal	A2A-Protokoll	MCP (Model Context Protocol)
Ziel	Agent ↔ Agent-Kommunikation	Agent ↔ Tool/Datenquelle-Verbindung
Szenario	Multi-Agenten-Zusammenarbeit und -Orchestrierung	Erweiterung der Fähigkeiten eines einzelnen Agenten
Kommunikationsmethode	JSON-RPC 2.0 über HTTP	JSON-RPC 2.0 über stdio/HTTP
Entdeckungsmechanismus	Agent Cards	MCP-Server-Registrierung
Typischer Anwendungsfall	Datenanalyse-Agent + Berichtserstellungs-Agent	Agent + GitHub/Datenbank/Dateisystem
Komplementäre Beziehung	„HTTP” zwischen Agenten	„USB” zwischen Agent und Tool

Beste Praxis: In modernen KI-Systemen werden A2A und MCP gemeinsam eingesetzt. Beispiel: Ein A2A-Koordinationsagent verbindet sich über MCP mit lokalen Tools und ruft gleichzeitig über A2A spezialisierte Agenten auf.

Kernkonzepte

1. Agent Card (Agenten-Karte)

Jeder A2A-kompatible Agent muss eine „Agenten-Karte” bereitstellen, die seine Fähigkeiten deklariert:

{
  "name": "Datenanalyse-Agent",
  "description": "Spezialisiert auf CSV/Excel-Datenanalyseaufgaben",
  "url": "https://agents.example.com/data-analyzer",
  "version": "1.0.0",
  "capabilities": {
    "inputFormats": ["text/csv", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
    "outputFormats": ["application/json", "text/markdown"],
    "skills": ["Statistische Analyse", "Datenvisualisierung", "Anomalieerkennung"]
  },
  "authentication": {
    "type": "bearer",
    "required": true
  }
}

2. Kommunikationsmodi

A2A unterstützt drei Kommunikationsmodi:

Synchrone Anfrage/Antwort — Für schnelle Aufgaben
Streaming-Antwort (SSE) — Für Langzeitaufgaben, Echtzeit-Fortschrittsrückmeldung
Asynchrone Push-Benachrichtigungen — Für zeitintensive Aufgaben, Rückruf nach Abschluss

3. Aufgaben-Statusmaschine

[Neu] → [In Bearbeitung] → [Abgeschlossen/Fehler/Abgebrochen]
              ↓
         [Eingabe benötigt] → [Fortsetzen]

Schnellstart

Systemanforderungen

Python: 3.10+
Node.js: 18+ (optional, für JS SDK)
Go: 1.21+ (optional, für Go SDK)
Java: 17+ (optional, für Java SDK)
.NET: 8.0+ (optional, für .NET SDK)

SDK-Installation

Python SDK (empfohlen)

# A2A Python SDK installieren
pip install a2a-sdk

# Installation überprüfen
python -c "import a2a; print(a2a.__version__)"

Node.js SDK

npm install @a2a-js/sdk

Go SDK

go get github.com/a2aproject/a2a-go

Java SDK (Maven)

<dependency>
  <groupId>org.a2a</groupId>
  <artifactId>a2a-sdk</artifactId>
  <version>0.3.0</version>
</dependency>

.NET SDK

dotnet add package A2A

Praxisbeispiel: Multi-Agenten-Kooperationssystem aufbauen

Szenario-Beschreibung

Angenommen, wir möchten einen „Content-Erstellungs-Workflow” aufbauen, der drei spezialisierte Agenten umfasst:

Recherche-Agent — Informationen suchen und aufbereiten
Schreib-Agent — Artikel basierend auf Rechercheergebnissen verfassen
Lektorat-Agent — Grammatik und Fakten prüfen

Schritt 1: Recherche-Agent-Server erstellen

# research_agent.py
from a2a.server import A2AServer
from a2a.types import AgentCard, Task, TaskStatus

class ResearchAgent:
    def __init__(self):
        self.card = AgentCard(
            name="Recherche-Agent",
            description="Suche und Aufbereitung von Web-Informationen",
            version="1.0.0",
            capabilities={
                "skills": ["Websuche", "Informationsextraktion", "Zusammenfassung"],
                "inputFormats": ["text/plain"],
                "outputFormats": ["application/json"]
            }
        )
    
    async def execute(self, task: Task):
        """Rechercheaufgabe ausführen"""
        query = task.input.text
        # Suchtool aufrufen (im tatsächlichen Projekt web_search oder Serper API integriert)
        results = await self.search_web(query)
        
        return Task(
            id=task.id,
            status=TaskStatus.COMPLETED,
            output={
                "summary": results.summary,
                "sources": results.sources,
                "key_points": results.key_points
            }
        )
    
    async def search_web(self, query: str):
        # Suchlogik implementieren
        pass

# Server starten
server = A2AServer(
    agent=ResearchAgent(),
    host="0.0.0.0",
    port=8080
)
server.run()

Schritt 2: Schreib-Agent-Client erstellen

# writing_agent.py
from a2a.client import A2AClient
from a2a.types import Task, TaskRequest

class WritingAgent:
    def __init__(self):
        self.research_client = A2AClient(
            agent_url="http://localhost:8080",
            api_key="dein-api-schlussel"
        )
    
    async def write_article(self, topic: str):
        # Schritt 1: Recherche-Agent zur Informationssammlung anfragen
        research_task = TaskRequest(
            input={"text": f"Recherchiere das Thema: {topic}, benötige Schlüsselfakten, Datenquellen und relevante Zitate"},
            mode="streaming"  # Streaming-Modus für Echtzeit-Fortschritt
        )
        
        research_result = await self.research_client.execute(research_task)
        
        # Schritt 2: Artikel basierend auf Rechercheergebnissen verfassen
        article = await self.generate_article(
            topic=topic,
            research_data=research_result.output
        )
        
        return article
    
    async def generate_article(self, topic: str, research_data: dict):
        # LLM zur Artikelerstellung aufrufen
        pass

# Anwendungsbeispiel
async def main():
    writer = WritingAgent()
    article = await writer.write_article("A2A-Protokoll im Detail")
    print(article)

import asyncio
asyncio.run(main())

Schritt 3: Vollständigen Workflow orchestrieren

# workflow_orchestrator.py
from a2a.client import A2AClient
from a2a.types import Task, TaskRequest

class ContentWorkflow:
    def __init__(self):
        self.research_agent = A2AClient("http://localhost:8080")
        self.writing_agent = A2AClient("http://localhost:8081")
        self.review_agent = A2AClient("http://localhost:8082")
    
    async def execute_workflow(self, topic: str):
        print(f"📝 Content-Erstellungs-Workflow starten: {topic}")
        
        # Phase 1: Recherche
        print("🔍 Phase 1: Informationssammlung...")
        research_task = TaskRequest(
            input={"text": topic},
            mode="sync"
        )
        research_result = await self.research_agent.execute(research_task)
        print(f"✅ Recherche abgeschlossen, {len(research_result.output['sources'])} Quellen gefunden")
        
        # Phase 2: Schreiben
        print("✍️  Phase 2: Artikelerstellung...")
        writing_task = TaskRequest(
            input={
                "topic": topic,
                "research_data": research_result.output
            },
            mode="streaming"
        )
        async for chunk in self.writing_agent.execute_stream(writing_task):
            print(f"📝 Schreibfortschritt: {chunk.progress}%")
        
        draft = chunk.output
        print(f"✅ Erster Entwurf fertig, {len(draft['content'])} Wörter")
        
        # Phase 3: Lektorat
        print("🔎 Phase 3: Qualitätsprüfung...")
        review_task = TaskRequest(
            input={
                "content": draft['content'],
                "check_types": ["grammar", "facts", "citations"]
            },
            mode="sync"
        )
        review_result = await self.review_agent.execute(review_task)
        
        print("✅ Workflow abgeschlossen!")
        return {
            "final_content": review_result.output['revised_content'],
            "quality_score": review_result.output['quality_score'],
            "suggestions": review_result.output['suggestions']
        }

# Workflow ausführen
async def main():
    workflow = ContentWorkflow()
    result = await workflow.execute_workflow("Entwicklungstrends von KI-Agenten 2026")
    print("\n📄 Fertiger Artikel:")
    print(result['final_content'])

asyncio.run(main())

Erweiterte Funktionen

1. Streaming-Antwortverarbeitung

async def handle_streaming_task(client: A2AClient, task: TaskRequest):
    async for event in client.execute_stream(task):
        if event.type == "progress":
            print(f"Fortschritt: {event.data['progress']}%")
        elif event.type == "partial_output":
            print(f"Teilergebnis: {event.data['content']}")
        elif event.type == "completed":
            print(f"Aufgabe abgeschlossen! Endergebnis: {event.data['output']}")

2. Fehlerbehandlung und Wiederholung

from a2a.exceptions import AgentUnavailable, TaskFailed

async def execute_with_retry(client: A2AClient, task: TaskRequest, max_retries=3):
    for attempt in range(max_retries):
        try:
            return await client.execute(task)
        except AgentUnavailable:
            if attempt == max_retries - 1:
                raise
            await asyncio.sleep(2 ** attempt)  # Exponentielles Backoff
        except TaskFailed as e:
            print(f"Aufgabe fehlgeschlagen: {e.message}")
            raise

3. Authentifizierung und Sicherheit

# Bearer-Token-Authentifizierung
client = A2AClient(
    agent_url="https://agents.example.com/analyzer",
    api_key="dein-geheimer-schluessel",
    auth_type="bearer"
)

# OAuth 2.0
from a2a.auth import OAuth2Provider

oauth = OAuth2Provider(
    client_id="deine-client-id",
    client_secret="dein-client-secret",
    token_url="https://auth.example.com/oauth/token"
)
client = A2AClient(
    agent_url="https://agents.example.com/analyzer",
    auth_provider=oauth
)

A2A-Ökosystem-Tools

Offizielle Ressourcen

GitHub-Repository: https://github.com/a2aproject/A2A
Protokollspezifikation: https://a2a-protocol.org/latest/specification/
Dokumentationsseite: https://a2a-protocol.org
Beispielcode: https://github.com/a2aproject/a2a-samples
Kostenloser Kurs: https://goo.gle/dlai-a2a (gemeinsam von Google Cloud + IBM Research erstellt)

Community-Tools

Tool	Beschreibung	Link
A2A Inspector	Debuggen und Prüfen von Agent Cards	`pip install a2a-inspector`
A2A Gateway	Agenten-Gateway und Lastverteilung	https://github.com/a2aproject/a2a-gateway
A2A Registry	Agenten-Entdeckung und Dienstregistrierung	https://github.com/a2aproject/a2a-registry

Best Practices

✅ Empfohlene Vorgehensweisen

Fähigkeiten klar deklarieren — Detaillierte Beschreibung der Agenten-Fähigkeiten und -Einschränkungen in der Agent Card
Streaming-Kommunikation nutzen — Für Aufgaben mit mehr als 5 Sekunden Laufzeit bevorzugt Streaming-Modus verwenden
Elegante Degradierung implementieren — Alternativlösungen bereitstellen, wenn abhängige Agenten nicht verfügbar sind
Interaktionen protokollieren — Zur Fehlersuche und Auditierung der Agenten-Kommunikation
Timeout-Grenzen setzen — Endloses Warten vermeiden, empfohlen 30-60 Sekunden Timeout

❌ Zu vermeidende Fallstricke

Übermäßige Abhängigkeit von einem einzelnen Agenten — Redundanzen und Alternativlösungen einplanen
Authentifizierung ignorieren — In Produktionsumgebungen muss Authentifizierung aktiviert sein
Sensible Daten offenlegen — Keine Implementierungsdetails in der Agent Card preisgeben
Synchrone Blockierung bei Langzeitaufgaben — Asynchrone oder Streaming-Modi für Langzeitaufgaben verwenden

Integration mit OpenClaw

Wenn du OpenClaw zum Aufbau von KI-Assistenten nutzt, kannst du A2A wie folgt integrieren:

# A2A-Agent in einer OpenClaw-Skill aufrufen
from a2a.client import A2AClient

async def a2a_research_task(query: str):
    """Externen Recherche-Agent aufrufen"""
    client = A2AClient("http://research-agent:8080")
    result = await client.execute({
        "input": {"text": query},
        "mode": "sync"
    })
    return result.output

# Als OpenClaw-Skill registrieren
# In skills/a2a-integration/SKILL.md definieren

Ausblick

Das A2A-Protokoll wird aktuell von der Linux Foundation verwaltet, mit Google als Hauptbeiträger. Die Entwicklungs-Roadmap für 2026 umfasst:

v0.4.0 (Q2 2026) — Multi-Modalitäts-Unterstützung (Bilder, Audio)
v0.5.0 (Q3 2026) — Einführung eines Agenten-Markt-Entdeckungsmechanismus
v1.0.0 (Q4 2026) — Offizielles Stable Release mit Abwärtskompatibilitätsgarantie

Mit dem Beitritt weiterer Unternehmen und Projekte zum A2A-Ökosystem können wir ein wirklich vernetztes KI-Agenten-Netzwerk erwarten — ebenso offen und interoperabel wie das heutige Web.

Fazit

Das A2A-Protokoll repräsentiert die nächste Phase der KI-Agenten-Entwicklung: von isolierten Intelligenzen hin zu kooperativen Agenten-Netzwerken. Für Entwickler ist jetzt der richtige Zeitpunkt, A2A zu lernen und zu übernehmen:

✅ Quelloffen und kostenlos — Apache 2.0 Lizenz, keine Nutzungsbeschränkungen
✅ Mehrsprachige Unterstützung — Python, JS, Go, Java, .NET
✅ Unterstützung von Großunternehmen — Von Google entwickelt, von der Linux Foundation verwaltet
✅ Ausgereiftes Ökosystem — Umfangreiche SDKs, Dokumentation und Beispiele
✅ Zukunftsorientiertes Design — Ergänzend zu MCP, für zukünftige Multi-Agenten-Systeme

Jetzt starten: Besuche https://github.com/a2aproject/A2A für den neuesten Code und die Dokumentation, oder lerne das A2A-Protokoll systematisch mit dem kostenlosen Kurs von Google.

Referenzen:

#A2A-Protokoll #Google #KI-Agent #Multi-Agenten-Systeme #Quelloffenes Protokoll #MCP