Agent-to-Agent Protocol (A2A)

1. Überblick über das Konzept und das systemische Problem

Bis zum Zeitraum 2025–2026 wurden die meisten Multi-Agenten-Systeme als starre proprietäre Monolithen aufgebaut (innerhalb einer einzigen Bibliothek wie LangGraph oder CrewAI). Mit dem Aufkommen zahlreicher spezialisierter kommerzieller Agenten (ein Sicherheitsaudit-Agent, ein Buchhaltungs-Agent, ein DevOps-Agent eines Cloud-Anbieters) entstand jedoch ein systemisches Problem:

• Ökosystem-Isolation: Ein Agent, der in einem internen Netzwerk auf Basis von PydanticAI läuft, kann keine Teilaufgaben sicher an einen Agenten im LangGraph-Ökosystem eines anderen Unternehmens delegieren.
• Fehlender einheitlicher Skill-Vertrag: Es gibt keinen universellen Weg, um herauszufinden, welche Aufgaben ein externer Agent lösen kann, was eine Anfrage kostet und welche SLA-Garantien er bietet.
• Kontextverlust beim Handoff: Die Übergabe von Prompts zwischen Systemen schneidet oft die Reasoning-Kette und systemseitige Constraints ab.

Das A2A Protocol (Agent-to-Agent) beseitigt diese Barrieren. Es ist ein standardisiertes Anwendungsprotokoll, das autonome Agenten zu vollwertigen Teilnehmern eines offenen Netzwerks macht, die in der Lage sind, die Fähigkeiten anderer zu entdecken (Discovery), Ausführungsbedingungen auszuhandeln (Negotiation) und Aufgaben sicher zu delegieren.

2. Architektonische Taxonomie und mentales Modell

Die Architektur des A2A-Protokolls basiert auf vier funktionalen Ebenen:

┌─────────────────────────────────────────────────────────────┐
│                 A2A PROTOCOL STACK ARCHITECTURE             │
├─────────────────────────────────────────────────────────────┤
│ 1. Semantic Discovery Layer                                 │
│    • Capability Manifests (Agent.json / JSON-LD)            │
│    • Skill Taxonomy & SLA Declarations                      │
├─────────────────────────────────────────────────────────────┤
│ 2. Negotiation & Contract Layer                             │
│    • Task Scoping & Constraint Bidding                      │
│    • Cost / Token Budget Allocation                         │
├─────────────────────────────────────────────────────────────┤
│ 3. Session & Handoff State Layer                            │
│    • Structured State Vectors & Memory Snapshots            │
│    • Execution Tracing & Callback Channels                  │
├─────────────────────────────────────────────────────────────┤
│ 4. Transport & Cryptographic Trust Layer                    │
│    • mTLS, Ed25519 Signatures, DID (Decentralized IDs)      │
│    • HTTP/3 Streams & Ephemeral WebSocket Tunnels           │
└─────────────────────────────────────────────────────────────┘

1. Discovery (Entdeckung): Der Agent veröffentlicht ein Manifest seiner Fähigkeiten (/.well-known/agent.json), das Aufgabentypen, erwartete Schemata für Eingabedaten und Sicherheitslimits enthält.
2. Negotiation (Verhandlung): Der initiierende Agent fragt die Ausführung einer Teilaufgabe an und gibt dabei das maximale Token-Budget, die Deadline sowie Rechtebeschränkungen an.
3. Execution & Handoff (Ausführung): Übergabe des minimal notwendigen Task-Kontexts in strukturierter Form.
4. Verification (Verifizierung): Überprüfung des kryptografisch signierten Ergebnisses und der Verbrauchsmetriken.

3. Technischer Pipeline-Prozess und interne Mechanik

Der typische Lebenszyklus einer A2A-Transaktion gestaltet sich wie folgt:

[ Primary Agent ]               [ Directory / DNS ]             [ Specialist Agent ]
       │                                 │                                │
       ├────── Query capabilities ───────►                                │
       │◄───── Endpoint & Public Key ────┤                                │
       │                                                                  │
       ├────── Send Task Contract (Schema, Tokens, Scope) ───────────────►│
       │                                                                  │ (Validate Auth &
       │                                                                  │  Resource Budget)
       │◄───── Accept / Propose Counter-Terms (Ack) ──────────────────────┤
       │                                                                  │
       ├────── Stream Context & Constraints ─────────────────────────────►│
       │                                                                  │ (Execute in Sandbox)
       │◄───── Stream Progress Events & Sub-Task Artifacts ───────────────┤
       │                                                                  │
       │◄───── Final Signed Result (Proof of Execution) ──────────────────┤

• Contract Validation: Die Parteien überprüfen die digitalen Signaturen der Anfragen, um Man-in-the-Middle-Angriffe oder die Unterwanderung durch System-Prompts zu verhindern.
• Context Encapsulation: Es wird nur der relevante Gedächtnisausschnitt (Task-Specific Slice) übertragen, nicht die gesamte Chat-Historie des Haupt-Agenten mit dem Nutzer, was die Vertraulichkeit gewährleistet.

4. Praktische Engineering-Szenarien im Production-Umfeld

01. Multi-Cloud DevOps Orchestrator

Ein lokaler Entwickler-Agent koordiniert den Release. Er wendet sich über A2A an einen externen Infrastruktur-Agenten von Hetzner zur Erstellung einer VPS und übergibt anschließend den erhaltenen Zugriff an einen Sicherheits-Agenten für das Audit offener Ports und die Generierung der UFW-Konfiguration.

02. Delegation komplexer mathematischer Berechnungen

Ein leichter Koordinations-Agent auf Basis des Gemini Flash Modells stößt auf ein komplexes Optimierungsproblem. Über A2A übergibt er die Aufgabe an einen spezialisierten Agenten auf Basis von DeepSeek-R1 mit dediziertem Python/NumPy Runtime und erhält eine signierte numerische Antwort zurück.

03. Cross-Platform Code Review Flotte

Ein Agent in der Cursor-Umgebung ruft einen unternehmensinternen Compliance-Agenten auf, der im privaten Netzwerk einer Bank bereitgestellt ist, und erhält vor dem Commit-Erzeugen ein Urteil bezüglich der Abwesenheit von PII-Daten und der Lizenzkonformität.

5. Fallstricke, häufige Fehler und Sicherheit

• Cascade Failure (Kaskadierende Ausfälle): Wenn ein Agent in einer A2A-Kette in einer Endlosschleife hängt, blockiert dies die gesamte Operation. Implementieren Sie zwingend harte Timeouts (Time-to-Live) für jeden Aufruf.
• Indirect Prompt Injection via A2A: Ein kompromittierter Spezial-Agent könnte ein Ergebnis liefern, das eine schädliche Anweisung für den Haupt-Agenten enthält. Jedes eingehende A2A-Ergebnis muss Schema-Validierung und Sanitization durchlaufen, da es als unsichere externe Daten behandelt werden muss.
• Unkontrollierter Budget-Leak: Gegenseitige Agenten-Aufrufe ohne globales Token-Limit können einen zyklischen Dialog („Danke – danke auch“) auslösen, der das Guthaben innerhalb weniger Minuten verbraucht.

6. Strategisches Fazit für Engineers im Jahr 2026

Das A2A-Protokoll führt die KI-Engineering-Praxis aus der Ära geschlossener Skripte in die Epoche des offenen Agenten-Internets. Wenn Sie heute Agent-Services designen, isolieren Sie deren interne Logik von der Kommunikations-Schnittstelle und integrieren Sie offene Interaktions-Spezifikationen, damit Ihre Agenten Teil global verteilter Systeme werden können.