ms-ai-architect/skills/ms-ai-engineering/references/agent-orchestration/agent-to-agent-communication.md

Agent-to-Agent Communication Protocols

Last updated: 2026-04 | Verified: MCP 2026-04 Status: GA Category: Agent Orchestration & Automation Type: reference Source: https://learn.microsoft.com/semantic-kernel/frameworks/agent/agent-orchestration

---

Innhold

• Introduksjon
• Kjernekomponenter
• Arkitekturmønstre
• Beslutningsveiledning
• Integrasjon med Microsoft-stakken
• Offentlig sektor (Norge)
• Kostnad og lisensiering
• For arkitekten (Cosmo)
• Kilder og verifisering

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) som støtter:

// 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):

{
  "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:

{
  "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

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

# 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:

// 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:

# 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:

// 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

// 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");

Microsoft Foundry

// 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

# 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)

// 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:

{
  "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:

// 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)