# Agent-to-Agent Communication Protocols

**Last updated:** 2026-04 | Verified: MCP 2026-04
**Status:** GA
**Category:** Agent Orchestration & Automation

---

## Introduksjon

Agent-to-agent communication i Microsoft-økosystemet handler om å få autonome AI-agenter til å samarbeide på tvers av plattformer, rammeverk og organisasjonsgrenser. I stedet for å bygge én monolittisk agent som kan alt, kan du orkestrere flere spesialiserte agenter som kommuniserer strukturert og sikkert.

Microsoft tilbyr to primære protokoller: **A2A (Agent-to-Agent)** som er en åpen, standardisert protokoll for rammeverksagnostisk kommunikasjon, og **Agent Registry API** via Microsoft Entra som legger til enterprise-sikkerhet, identitet og governance. Sammen gir de en fullstendig stack for agent-samarbeid – fra discovery til autentisert, sporbar kommunikasjon.

Den kritiske verdien ligger i **interoperabilitet**: en agent bygget med Semantic Kernel kan samarbeide med en agent bygget med AutoGen, en custom engine, eller til og med tredjepartsrammeverk. Dette bryter ned siloer og tillater gjenbruk av agenter på tvers av applikasjoner, team og organisasjoner.

## Kjernekomponenter

| Komponent | Formål | Teknologi |
|-----------|--------|-----------|
| **A2A Protocol** | Standardisert meldingsprotokoll for agent-kommunikasjon | Agent discovery, message-based communication, long-running tasks, cross-platform interoperability |
| **Agent Card** | JSON-dokument som fungerer som "visittkort" for agenter | Metadata om identity, capabilities, endpoint, skills, authentication requirements |
| **Client Agent** | Agent som initierer kommunikasjon og orkestrerer interaksjoner | Semantic Kernel, AutoGen, custom engines |
| **Remote Agent** | Agent som mottar requests og utfører tasks | Eksponerer HTTP endpoint, implementerer A2A-protokollen |
| **Agent Registry API** | Enterprise-katalog for agent discovery og governance | Microsoft Entra, OAuth 2.0, policy enforcement |
| **Message Broker** | Håndterer asynkron kommunikasjon mellom agenter | Azure Service Bus, Azure Event Grid |

### A2A Protocol (Open Standard)

A2A er en åpen standardprotokoll (spesifikasjon: [a2a-protocol.org](https://a2a-protocol.org/latest/)) som støtter:

```csharp
// Eksponere en agent via A2A
app.MapA2A(agent, "/a2a/my-agent", agentCard: new()
{
    Name = "My Agent",
    Description = "A helpful agent that assists with tasks.",
    Version = "1.0",
    Capabilities = new()
    {
        Streaming = true,
        PushNotifications = false
    }
});
```

**Message Format** (JSON-RPC):

```json
{
  "message": {
    "kind": "message",
    "role": "user",
    "parts": [
      {
        "kind": "text",
        "text": "What is the temperature rating of the product?",
        "metadata": {}
      }
    ],
    "messageId": "guid-or-null",
    "contextId": "conversation-id"
  }
}
```

**Response Format**:

```json
{
  "kind": "message",
  "role": "agent",
  "parts": [
    {
      "kind": "text",
      "text": "The temperature rating is -10°C."
    }
  ],
  "messageId": "chatcmpl-XYZ",
  "contextId": "conversation-id"
}
```

### Agent Card (Discovery)

Agent Card er et JSON-manifest som beskriver agentens:
- **Identity**: Navn, versjon, beskrivelse
- **Capabilities**: Streaming, push notifications, skills
- **Endpoint**: Base URL for kommunikasjon
- **Authentication**: OAuth scopes, token requirements

```http
GET https://your-agent-host/.well-known/agent-card.json
```

### Microsoft Entra Agent Registry

For enterprise-scenarioer legger Agent Registry til:

| Funksjon | Beskrivelse |
|----------|-------------|
| **Agent Identity** | Hver agent får en `agentIdentityId` i Entra |
| **Discovery Policies** | Secure-by-default + custom policies |
| **Audit Trails** | Alle agent-interaksjoner logges med `traceId` |
| **Authorization** | OAuth 2.0 tokens, role-based access control |

```http
# Query registry by skills
GET https://graph.microsoft.com/beta/agentRegistry/agentCardManifests?$filter=displayName eq 'Sample Agent'&$select=id,displayName,skills
Authorization: Bearer {token}
```

### Message Brokers (Async Communication)

For event-driven agent-samarbeid:

| Tjeneste | Use Case | Pattern |
|----------|----------|---------|
| **Azure Service Bus** | Reliable message queuing, topic-based pub/sub | Asynchronous messages, guaranteed delivery |
| **Azure Event Grid** | Real-time event routing (10M events/sec) | Event-driven workflows, reactive agents |
| **Azure Event Hubs** | High-throughput event streaming (IoT) | Stream processing, telemetry aggregation |

## Arkitekturmønstre

### 1. Direct A2A Communication (Lightweight)

**Fordeler:**
- Minimal overhead, direkte HTTP-kommunikasjon
- Ingen avhengighet til enterprise-infrastruktur
- Ideell for tight-coupled systemer eller dev/test

**Ulemper:**
- Ingen innebygd discovery (må kjenne endpoint manuelt)
- Begrenset sikkerhet (kun HTTPS + API keys)
- Ingen audit trail ut av boksen

**Implementasjon:**

```csharp
// Eksponere agent
app.MapA2A(agent, "/a2a/agent", agentCard: new() { Name = "Agent" });

// Koble til remote agent (direct config)
A2AClient client = new(new Uri("https://remote-agent/a2a/endpoint"));
AIAgent remoteAgent = client.AsAIAgent();

// Sende melding
await foreach (var response in remoteAgent.InvokeAsync(
    new ChatMessageContent(AuthorRole.User, "What can you do?"),
    thread))
{
    Console.WriteLine(response.Content);
}
```

**Når brukes dette:**
- POC og prototyper
- Interne systemer uten governance-krav
- Agent-to-agent kommunikasjon innenfor samme applikasjon

### 2. Agent Registry (Enterprise-grade)

**Fordeler:**
- Sentralisert discovery via Graph API queries
- OAuth 2.0 autentisering og autorisasjon
- Audit logging og compliance (GDPR, AI Act)
- Policy enforcement (secure-by-default, custom policies)

**Ulemper:**
- Krever Microsoft Entra ID
- Mer kompleks oppsett
- Latens fra registry lookup (caching mitigerer dette)

**Implementasjon:**

```http
# 1. Valider at client agent har agent ID
GET https://graph.microsoft.com/beta/agentRegistry/agentInstances/{agent-id}

# 2. Query registry for agenter med spesifikke skills
GET https://graph.microsoft.com/beta/agentRegistry/agentCardManifests?$filter=skills/any(s:s eq 'translation')&$select=id,displayName,skills
Authorization: Bearer {token}

# 3. Hent agent card (baseUrl + capabilities)
# Response inneholder agent manifest JSON

# 4. Send collaboration message (JSON-RPC)
POST https://{baseUrl}/v1/message:stream
Authorization: Bearer {registry-issued-token}
{
  "method": "processTask",
  "params": { "input": "data" },
  "traceId": "audit-trace-id",
  "caller": "registry-token"
}
```

**Når brukes dette:**
- Multi-tenant SaaS-løsninger
- Kryssfunksjonelt agent-samarbeid (HR, Finance, IT)
- Regulatory compliance (offentlig sektor, finans, helse)

### 3. Event-Driven Agent Orchestration

**Fordeler:**
- Høy skalerbarhet (millions events/sec med Event Grid)
- Dekobling av produsenter og konsumenter
- Resiliens (retry, dead-letter queues)

**Ulemper:**
- Eventual consistency (ikke egnet for synkrone workflows)
- Kompleks feilhåndtering (distributed transactions)
- Vanskelig debugging (asynkrone flows)

**Implementasjon:**

```csharp
// Publiser event fra Agent A
await eventBus.PublishAsync(new AgentCompletedEvent
{
    AgentId = "agent-a",
    Result = result,
    NextAgent = "agent-b"
});

// Agent B subscriber
eventBus.Subscribe<AgentCompletedEvent>(async evt =>
{
    if (evt.NextAgent == "agent-b")
    {
        await agentB.ProcessAsync(evt.Result);
    }
});
```

**Topologier:**

| Topologi | Beskrivelse | Use Case |
|----------|-------------|----------|
| **Broker Topology** | Agenter broadcaster events, andre agenter reagerer eller ignorerer. Hoey dekobling, men mangler innebygd error handling og distributed transaction-stoette | Dynamiske workflows, ingen sentral koordinering |
| **Mediator Topology** | En mediator styrer event flow og state, dispatcher commands til dedikerte kanaler. Bedre feilhaandtering og datakonsistens, men oekt kobling og potensielt bottleneck | Komplekse workflows med error handling og state management |

**Event-driven utfordringer ved agent-kommunikasjon:**
- **Eventual consistency:** Data paa tvers av agenter er ikke umiddelbart konsistent. Design for dette bevisst.
- **Ordering:** Ved skalering kan events motttas i feil rekkefoelge. Bruk partisjonsnoekler og idempotent processing.
- **Observability:** Inkluder correlation ID i alle events fra start — retrofit er vanskelig.
- **Schema evolution:** Definer versjonsstrategi tidlig. Design consumers til aa haandtere ukjente event-versjoner.

**Når brukes dette:**
- Lang-levende workflows (timer/dager)
- IoT-scenarier med høy throughput
- Loose coupling mellom agenter

## Beslutningsveiledning

### Velg riktig protokoll

| Scenario | Anbefalt | Begrunnelse |
|----------|----------|-------------|
| POC / prototype | A2A Direct | Minimal setup, rask iterasjon |
| Intern applikasjon, 2-5 agenter | A2A Direct | Lav kompleksitet, kjente endpoints |
| Multi-tenant SaaS | Agent Registry | Discovery, audit, security |
| Offentlig sektor | Agent Registry | Compliance, GDPR, auditability |
| High-throughput events (>1000/sec) | Event Grid + A2A | Skalerbarhet, async processing |
| Long-running tasks (>15 sec) | Service Bus + A2A | Reliable delivery, retry logic |

### Vanlige feil

| Feil | Konsekvens | Løsning |
|------|------------|---------|
| Hardkode endpoint URLs | Brittle, ingen failover | Bruk discovery (registry eller well-known location) |
| Manglende `contextId` | Tap av conversation history | Alltid send `contextId` for multi-turn dialogs |
| Synkron blocking på long tasks | Timeout, poor UX | Bruk async messages eller tasks (A2A støtter long-running tasks) |
| Ignorere auth i A2A | Security risk | Implementer OAuth 2.0 for registry, eller API keys + HTTPS for direct |
| Ingen error handling | Cascading failures | Bruk circuit breakers, retry policies, dead-letter queues |

### Røde flagg

- **"Alle agenter skal bruke samme LLM-deployment"** → Agenter bør være autonome med egne ressurser
- **"Vi trenger én mega-agent i stedet for flere"** → Monolitt-smell, bruk kompozisjon
- **"Agent A kaller Agent B som kaller Agent C synkront"** → Chain kan blokkere, vurder async orchestration
- **"Vi logger ikke agent-interaksjoner"** → Compliance-risiko, spesielt i offentlig sektor

## Integrasjon med Microsoft-stakken

### Semantic Kernel Agent Framework

```csharp
// A2A Agent som Semantic Kernel agent
A2ACardResolver resolver = new(new Uri("https://agent-host"));
AIAgent agent = await resolver.GetAIAgentAsync();

// Bruk i orchestration (Group Chat, Sequential, Handoff)
GroupChatOrchestration orchestration = new([agent1, agent2, a2aAgent]);
await orchestration.InvokeAsync("Collaborate on this task");
```

### Azure AI Foundry

```csharp
// A2A Tool i Foundry agent
A2APreviewTool a2aTool = new()
{
    ProjectConnectionId = connection.Id,
    BaseUri = new Uri("https://remote-agent/a2a")
};

PromptAgentDefinition agentDef = new(model: "gpt-4o")
{
    Instructions = "You are a helpful assistant.",
    Tools = { a2aTool }
};
```

### Copilot Studio

Copilot Studio kan **konsumere** A2A-agenter via:
- **Custom connectors** (HTTP endpoint til A2A agent)
- **Power Automate flows** (orkestrere A2A calls)

### Power Platform

```yaml
# Power Automate flow
trigger: When a new item is created
action: HTTP POST to A2A agent
  url: https://agent-host/a2a/agent/v1/message
  body: { "message": { "role": "user", "parts": [...] } }
  headers: Authorization: Bearer {token}
```

### Azure Service Bus (Async)

```csharp
// Agent publisher
await serviceBus.SendMessageAsync(new ServiceBusMessage
{
    Body = BinaryData.FromObjectAsJson(agentTask),
    Subject = "agent-collaboration",
    CorrelationId = contextId
});

// Agent subscriber
await serviceBus.ProcessMessageAsync(async msg =>
{
    var task = msg.Body.ToObjectFromJson<AgentTask>();
    await remoteAgent.InvokeAsync(task);
});
```

## Offentlig sektor (Norge)

### GDPR og datasuverenitet

| Krav | Implementasjon |
|------|----------------|
| **Personvern by design** | Agent Card må deklarere hvilke data som prosesseres |
| **Behandlingsgrunnlag** | Logg `contextId` + `traceId` for å spore samtykke |
| **Dataportabilitet** | Eksporter conversation history fra agent sessions |
| **Rett til sletting** | Implementer `DELETE /sessions/{contextId}` endpoint |

**Agent Card-eksempel**:

```json
{
  "name": "NAV Assistant",
  "version": "1.0",
  "capabilities": {
    "dataProcessing": {
      "personalData": true,
      "dataCategories": ["navn", "fødselsnummer"],
      "retentionDays": 90,
      "dataLocation": "Norway East"
    }
  }
}
```

### AI Act (EU Forordning 2024)

| High-Risk System Krav | A2A Mapping |
|------------------------|-------------|
| **Transparens** | Agent Card må deklarere AI-modell og capabilities |
| **Human oversight** | Implementer human-in-the-loop via approval flows i Registry policies |
| **Sporbarhet** | Agent Registry audit logs + `traceId` i alle messages |
| **Risikovurdering** | DPIA for agenter som håndterer persondata |

### Forvaltningsloven § 11a (Automatiserte vedtak)

**Kritisk**: Agenter som bidrar til vedtaksprosesser må:
1. **Logge beslutningstrekk** → Bruk `traceId` og structured logging
2. **Tillate manuell overstyring** → Human-in-the-loop i mediator topology
3. **Dokumentere grunnlag** → Agent conversation history som vedlegg

**Implementasjon**:

```csharp
// Log agent collaboration for audit
logger.LogInformation(
    "Agent {AgentId} collaborated with {RemoteAgent} for case {CaseId}. TraceId: {TraceId}",
    agentId, remoteAgentId, caseId, traceId);
```

### Schrems II og dataoverføring

- **Unngå US-baserte agents** uten Data Privacy Framework-sertifisering
- **Krev Agent Card-deklarasjon** om data residency
- **Bruk Azure Norway East/West** for hosting av lokale agenter

## Kostnad og lisensiering

### A2A Protocol (Open Source)

- **Ingen lisenskostnader** for protokollen selv
- **Hosting-kostnader**: Azure App Service eller Container Apps (ca. 500-2000 NOK/mnd per agent)

### Agent Registry API

| Komponent | Kostnad | Estimat |
|-----------|---------|---------|
| **Microsoft Entra ID P2** | Required for Agent Registry | 62 NOK/bruker/mnd |
| **Graph API calls** | Gratis opp til 10 000/dag, deretter ca. 0,50 NOK/1000 calls | Typisk neglisjerbar |
| **Audit logs** | Inkludert i Entra P2 | Gratis (90 dagers retention) |

### Compute-kostnader (Azure)

| Agent Hosting Scenario | Anbefalt | Månedlig kostnad (estimat) |
|------------------------|----------|----------------------------|
| 1-5 lightweight agents | App Service Basic B1 | 500 NOK |
| 5-20 agents, moderat last | App Service Standard S1 | 1500 NOK |
| 20+ agents, høy last | Container Apps (autoscaling) | 3000-10000 NOK |
| Event-driven (Service Bus) | Standard tier | 350 NOK + 0,05 NOK/million operations |

### Optimaliseringstips

1. **Caching av Agent Cards** → Reduser Graph API calls (cache i 1 time)
2. **Batching av messages** → Kombiner flere requests til én A2A call
3. **Async over sync** → Bruk Service Bus for non-realtime workflows (billigere enn Azure Functions)
4. **Shared compute** → Kjør flere lightweight agents på samme App Service

## For arkitekten (Cosmo)

### Spørsmål å stille

1. **Hvor mange agenter forventes?**
   - <5: A2A Direct
   - 5-20: Agent Registry uten custom policies
   - 20+: Agent Registry med collection-basert governance

2. **Er discovery et krav?**
   - Nei: A2A Direct med hardkodede endpoints
   - Ja: Agent Registry eller custom registry (Redis/Cosmos DB)

3. **Må dere spore hvem som kommuniserte med hvem?**
   - Ja → Agent Registry (audit logs)
   - Nei → A2A Direct (men implementer egen logging)

4. **Finnes det compliance-krav?**
   - GDPR/AI Act → Agent Registry + audit logging
   - Forvaltningsloven → Human-in-the-loop + structured logging

5. **Hvor lang tid tar tasks?**
   - <15 sek: Synkron A2A
   - 15 sek - 5 min: A2A long-running tasks
   - >5 min: Service Bus + async processing

6. **Trenger dere cross-org collaboration?**
   - Ja → Agent Registry med federated identity
   - Nei → A2A Direct innenfor eget Entra tenant

7. **Hva er latenskrav?**
   - <100ms: A2A Direct (HTTP)
   - <1 sek: Agent Registry (caching mitigerer lookup)
   - >1 sek OK: Event Grid (eventual consistency)

8. **Må agenter oppdages dynamisk?**
   - Ja → Agent Registry med skill-based queries
   - Nei → A2A Direct med config-basert routing

### Fallgruver

| Fallgruve | Konsekvens | Mitigering |
|-----------|------------|-----------|
| **Synkron A2A chain (A→B→C→D)** | Latens akkumulerer, timeout risk | Bruk mediator topology eller async |
| **Manglende retry logic** | Midlertidige feil stopper workflows | Circuit breaker pattern, exponential backoff |
| **Ingen versjonering av Agent Cards** | Breaking changes bryter clients | Semantic versioning (v1, v2) i endpoint paths |
| **Overbruk av Registry queries** | Throttling, kostnader | Cache agent cards i 1+ time |
| **Hardkodet baseUrl** | Ingen failover ved downtime | Bruk well-known locations eller registry |

### Anbefalinger per modenhetsnivå

#### **Nivå 1: POC (0-3 måneder)**
- A2A Direct med 2-3 agenter
- Hardkodede endpoints
- Minimal sikkerhet (HTTPS + API keys)

**Metrics**: Time to first A2A call (<1 dag)

#### **Nivå 2: Pilot (3-12 måneder)**
- Agent Registry for discovery
- OAuth 2.0 autentisering
- Basic audit logging
- 5-10 agenter

**Metrics**: Agent discovery latens (<500ms), uptime (>99%)

#### **Nivå 3: Produksjon (12+ måneder)**
- Agent Registry med custom policies
- Event-driven orchestration (Service Bus + A2A hybrid)
- Full audit compliance (GDPR, AI Act)
- 20+ agenter, multi-tenant

**Metrics**: Audit coverage (100%), policy violations (0), mean agent response time (<2 sek)

### Decision Tree

```
Trenger dere agent discovery?
├─ Nei → A2A Direct
│   └─ Er det høy throughput (>1000 msg/sek)?
│       ├─ Nei → HTTP A2A
│       └─ Ja → Event Grid + A2A
└─ Ja → Agent Registry
    └─ Er det compliance-krav?
        ├─ Nei → Registry uten custom policies
        └─ Ja → Registry + audit + policies
```

## Kilder og verifisering

### Microsoft Learn (Verified)

1. **A2A Protocol Specification**
   - https://learn.microsoft.com/en-us/agent-framework/user-guide/hosting/agent-to-agent-integration
   - Confidence: **Verified** (offisiell A2A guide, desember 2024)

2. **Agent Registry API**
   - https://learn.microsoft.com/en-us/entra/agent-id/identity-platform/registry-agent-to-agent-protocol
   - Confidence: **Verified** (Microsoft Entra docs, januar 2025)

3. **Semantic Kernel Agent Orchestration**
   - https://learn.microsoft.com/en-us/semantic-kernel/frameworks/agent/agent-orchestration/
   - Confidence: **Verified** (SK 1.0+ docs, januar 2025)

4. **Event-Driven Architecture (Azure)**
   - https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/event-driven
   - Confidence: **Verified** (Azure Architecture Center, oppdatert 2026-04: broker vs mediator topology, eventual consistency, ordering, observability, schema evolution)

5. **Azure Service Bus Integration**
   - https://learn.microsoft.com/en-us/dotnet/architecture/microservices/multi-container-microservice-net-applications/integration-event-based-microservice-communications
   - Confidence: **Verified** (Microservices architecture guide, 2024)

### External Standards (Verified)

6. **A2A Protocol Specification (a2a-protocol.org)**
   - https://a2a-protocol.org/latest/
   - Confidence: **Verified** (offisiell protokoll-spec, versjon 1.0)

7. **JSON-RPC 2.0 Specification**
   - https://www.jsonrpc.org/specification
   - Confidence: **Verified** (brukt av A2A message format)

### Confidence per seksjon

| Seksjon | Confidence | Kilde |
|---------|-----------|-------|
| A2A Protocol | Verified | MS Learn + a2a-protocol.org |
| Agent Registry | Verified | MS Entra docs |
| Event-Driven Patterns | Verified | Azure Architecture Center |
| Semantic Kernel Integration | Verified | SK 1.0 docs |
| GDPR/AI Act mapping | Baseline | LLM kunnskap + NO compliance praksis |
| Kostnad/priser | Baseline | Azure pricing calculator (jan 2025) |

**Total sources cited**: 7 unique URLs fra MCP-research
**MCP calls**: 4 (3x search, 2x fetch, 1x code samples)
