Implementation Plan: A2A Protocol & Semantic Kernel Integration

Integrate the Agent2Agent (A2A) protocol and Microsoft Semantic Kernel to enable SEA™ agents to:

1. Communicate externally via A2A with agents built on LangGraph, CrewAI, Google ADK, and other frameworks
2. Orchestrate internally via Semantic Kernel for workflows, plugins, and memory integration
3. Expose capabilities through the A2A Agent Card derived from Semantic Kernel plugins

Historical Note: IBM’s Agent Client Protocol (ACP) has been merged into A2A under the Linux Foundation as of March 2025. This plan implements A2A as the unified agent communication standard, which includes the capabilities previously specified by ACP.

Gap Closure: Semantic Kernel was identified as 🟡 High priority in docs/assets/dependency_gap_analysis.md but not yet implemented. This plan closes that gap by integrating it alongside A2A.

Provenance & Traceability

Architectural Decisions (ADRs)

Product Requirements (PRDs)

Software Design Specifications (SDS)

Provenance Chain

graph TD
    ADR38[ADR-038: A2A + Semantic Kernel] --> PRD27[PRD-027: External Agent Interoperability]
    ADR17[ADR-017: MCP-LSP Integration] --> PRD27
    ADR32[ADR-032: JetStream Messaging] --> PRD27
    ADR33[ADR-033: Kernel-Shell] --> PRD27
    PRD27 --> SDS56[SDS-056: A2A Protocol Gateway]
    PRD27 --> SDS57[SDS-057: Semantic Kernel Orchestration]
    SDS56 --> SDS52[SDS-052: Semantic Tooling - Tool Surface Extension]
    SDS57 --> SDS31[SDS-031: Authority - Agent Delegation Rules]

Architecture and Design

A2A Protocol Overview

A2A (Agent2Agent) is an open standard for agent-to-agent communication:

Core Concepts:

• Agent Card: JSON metadata describing agent identity, capabilities, skills, and authentication
• Task: Stateful unit of work with lifecycle (submitted → working → input-required → completed/failed/canceled)
• Message: Communication turn with Parts (TextPart, FilePart, DataPart)
• Artifact: Output generated by an agent (documents, structured data, files)
• Streaming: Real-time updates via SSE or gRPC streams
• Push Notifications: Async updates via webhooks for long-running tasks

Protocol Bindings Supported:

• JSON-RPC 2.0 over HTTP/HTTPS
• gRPC with streaming
• HTTP+JSON/REST

Relationship to MCP and Semantic Kernel:

• MCP = Agent-to-Tool (how agents use capabilities/resources)
• A2A = Agent-to-Agent (how agents collaborate as peers)
• Semantic Kernel = Internal Agent Orchestration (workflows, plugins, memory)

Semantic Kernel Overview

Microsoft Semantic Kernel is an open-source SDK for building AI agents:

Core Capabilities:

• Plugin System: Expose functions as reusable AI capabilities
• Planner: Automatic function orchestration for complex goals
• Memory: Vector storage integration for semantic recall
• Connectors: Built-in adapters for OpenAI, Azure, Hugging Face, etc.
• Filters: Pre/post execution hooks for governance and observability

Why Semantic Kernel + A2A:

Integration Strategy:

1. SEA™’s Semantic Kernel plugins become A2A Agent Card “skills”
2. A2A tasks are dispatched to Semantic Kernel for execution
3. Semantic Kernel filters enforce SDS-031 governance before/after execution
4. Memory context is shared between internal Semantic Kernel and external A2A conversations

Integration Architecture

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
┌─────────────────────────────────────────────────────────────────────────────┐
│                            SEA™ Agent Runtime                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  ┌────────────────────────────────────────────────────────────────────────┐ │
│  │                    A2A Protocol Gateway (SDS-055)                       │ │
│  │  ┌─────────────────────┐              ┌─────────────────────┐          │ │
│  │  │   A2A Server        │              │   A2A Client        │          │ │
│  │  │   (Receive Tasks)   │              │   (Delegate Tasks)  │          │ │
│  │  │                     │              │                     │          │ │
│  │  │  • /agent-card      │              │  • Task Delegation  │          │ │
│  │  │  • /tasks (CRUD)    │              │  • Agent Discovery  │          │ │
│  │  │  • /messages        │              │  • Streaming Client │          │ │
│  │  │  • Streaming (SSE)  │              │                     │          │ │
│  │  └────────┬────────────┘              └──────────┬──────────┘          │ │
│  │           │                                      │                      │ │
│  └───────────┼──────────────────────────────────────┼──────────────────────┘ │
│              │                                      │                        │
│  ┌───────────▼──────────────────────────────────────▼──────────────────────┐ │
│  │                    Agent Task Router (Kernel)                            │ │
│  │  • Maps A2A tasks to internal commands/queries                          │ │
│  │  • Enforces HITL escalation (SDS-031 §7)                                │ │
│  │  • Manages task lifecycle                                                │ │
│  └──────────────────────────────────────────────────────────────────────────┘ │
│              │                                      │                        │
│  ┌───────────▼────────────────────┐    ┌───────────▼────────────────────┐   │
│  │  MCP Tool Surface (SDS-052)    │    │  JetStream (SDS-047)           │   │
│  │  (Execute local capabilities)  │    │  (Async event processing)       │   │
│  └────────────────────────────────┘    └────────────────────────────────┘   │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

                              External Agents
                    ┌──────────────────────────────────┐
                    │  🤖 Remote Agent 1 (LangGraph)   │
                    │  🤖 Remote Agent 2 (CrewAI)      │
                    │  🤖 Remote Agent 3 (Custom)      │
                    └──────────────────────────────────┘

Design Principles Applied

• Isomorphism: Agent capabilities declared in Agent Card map 1:1 to MCP tool surface (SDS-052).
• Invariants: All incoming A2A tasks go through HITL escalation for mutating operations (SDS-031).
• Idempotency: Task IDs are stable; retries are idempotent based on message ID.

Dependency Justification

A2A Protocol Dependencies

Semantic Kernel Dependencies

Installation Commands

1
2
3
4
5
6
7
8
# Python (for FastAPI A2A server + Semantic Kernel)
pip install a2a semantic-kernel[all]

# Node.js (for VS Code extension A2A client)
pnpm add @a2a/sdk

# Optional: .NET SDK for Azure deployments
# dotnet add package Microsoft.SemanticKernel

Expected Filetree

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/
├── schemas/a2a/
│   ├── agent-card.schema.json           # SEA™ Agent Card JSON schema
│   ├── task-request.schema.json         # Validated task request format
│   └── artifact-envelope.schema.json    # Output artifact wrapper
├── docs/specs/shared/
│   ├── adr/038-a2a-protocol-integration.md
│   ├── prd/026-external-agent-interoperability.md
│   └── sds/055-a2a-protocol-gateway.sds.yaml
├── libs/sea/adapters/a2a/
│   └── src/
│       ├── a2a-server.adapter.py        # FastAPI A2A server
│       ├── a2a-client.adapter.py        # A2A client for delegation
│       ├── agent-card.py                # Agent Card generator
│       └── task-router.py               # A2A task → kernel command router
├── libs/sea/adapters/semantic-kernel/
│   └── src/
│       ├── kernel-factory.py            # Semantic Kernel builder
│       ├── plugins/                     # SEA™ capability plugins
│       │   ├── semantic_analysis.py     # Code/spec analysis plugin
│       │   ├── artifact_generation.py   # CADSL/diagram generation
│       │   └── governance_check.py      # Policy enforcement plugin
│       ├── memory/                      # Memory adapters
│       │   └── pgvector-memory.py       # PostgreSQL vector memory
│       └── filters/                     # Governance filters
│           ├── hitl-filter.py           # HITL escalation filter
│           └── audit-filter.py          # Audit logging filter
└── apps/sea-api/
    └── src/
        └── routes/a2a/                  # A2A HTTP routes
            ├── agent_card.py            # /.well-known/agent.json
            ├── tasks.py                 # /tasks CRUD
            └── messages.py              # /tasks/{id}/messages

Proposed Cycles

Task Breakdown

Wave 1: Specification Foundation (Parallel)

• C1A: Create ADR, PRD, and SDS for A2A + Semantic Kernel Integration
  • Implements: Architectural decision for multi-agent interoperability
  • Satisfies: Enterprise multi-agent strategy alignment
  • Files: docs/specs/shared/adr/038-a2a-semantic-kernel-integration.md, docs/specs/shared/prd/026-external-agent-interoperability.md, docs/specs/shared/sds/055-a2a-protocol-gateway.sds.yaml, docs/specs/shared/sds/056-semantic-kernel-orchestration.sds.yaml
• C1B: Define SEA™ Agent Card schema and generator
  • Implements: A2A Agent Card for SEA™ agent discovery
  • Satisfies: PRD-026 REQ-070 (Agent Discovery)
  • Files: schemas/a2a/agent-card.schema.json, libs/sea/adapters/a2a/src/agent-card.py
• C1C: Initialize Semantic Kernel factory and base configuration
  • Implements: Kernel builder with SEA-specific settings
  • Satisfies: SDS-040 (LLM Orchestration)
  • Dependencies: semantic-kernel[all]
  • Files: libs/sea/adapters/semantic-kernel/src/kernel-factory.py

Wave 2: Semantic Kernel Core (Depends on Wave 1)

• C2A: Implement core Semantic Kernel plugins
  • Implements: SEA™ capability plugins for analysis and generation
  • Satisfies: PRD-001 (AI Generative Capabilities), PRD-002 (Cognitive Amplification)
  • Plugins:
    • semantic_analysis.py - Code/spec semantic analysis
    • artifact_generation.py - CADSL/diagram generation
    • governance_check.py - Policy enforcement
  • Files: libs/sea/adapters/semantic-kernel/src/plugins/*
• C2B: Implement Semantic Kernel governance filters
  • Implements: Pre/post execution hooks for HITL and audit
  • Satisfies: SDS-031 §7 (HITL Protocol), REF-012 (Governance Invariants)
  • Filters:
    • hitl-filter.py - Human-in-the-loop escalation
    • audit-filter.py - Audit logging for all executions
  • Files: libs/sea/adapters/semantic-kernel/src/filters/*
• C2C: Implement pgvector memory adapter for Semantic Kernel
  • Implements: Vector memory using existing pgvector infrastructure
  • Satisfies: PRD-002 (Context-Aware Recommendations)
  • Files: libs/sea/adapters/semantic-kernel/src/memory/pgvector-memory.py

Wave 3: A2A Server + Bridge (Depends on Wave 2)

• C3A: Implement A2A Server adapter (FastAPI)
  • Implements: A2A server endpoints for receiving tasks from external agents
  • Satisfies: PRD-026 REQ-071 (Task Reception), REQ-072 (Message Exchange)
  • Files: libs/sea/adapters/a2a/src/a2a-server.adapter.py, apps/sea-api/src/routes/a2a/*
• C3B: Implement A2A → Semantic Kernel bridge
  • Implements: Route incoming A2A tasks to Semantic Kernel for execution
  • Satisfies: PRD-026 REQ-073 (Governed Task Execution)
  • Flow: A2A Task → Kernel Filter (HITL) → SK Plugin Execution → A2A Artifact
  • Files: libs/sea/adapters/a2a/src/task-router.py

Wave 4: A2A Client & Streaming (Depends on Wave 3)

• C4A: Implement A2A Client adapter for task delegation
  • Implements: Delegating sub-tasks to external A2A-compliant agents
  • Satisfies: PRD-026 REQ-074 (Task Delegation)
  • Files: libs/sea/adapters/a2a/src/a2a-client.adapter.py
• C4B: Implement SSE streaming for real-time updates
  • Implements: Server-Sent Events for streaming task status and artifacts
  • Satisfies: PRD-026 REQ-075 (Streaming Updates)
  • Files: apps/sea-api/src/routes/a2a/streaming.py

Wave 5: Async & Production Ready (Depends on Wave 4)

• C5A: Implement push notification webhooks
  • Implements: Async task update delivery via webhooks
  • Satisfies: PRD-026 REQ-076 (Push Notifications)
  • Files: Extends docs/specs/shared/sds/047-messaging-infrastructure.md

Validation & Verification

Spec Validation

• SDS-055 defines all A2A operations (SendMessage, GetTask, CancelTask, etc.)
• SDS-056 defines Semantic Kernel plugin interface and filter contracts
• Agent Card schema validates against A2A specification
• Task lifecycle states match A2A spec (submitted, working, input-required, completed, failed, canceled)

Implementation Validation

A2A Protocol:

• Agent Card served at /.well-known/agent.json (A2A discovery convention)
• A2A server passes interoperability tests with reference implementations
• Streaming updates delivered in <100ms for active connections
• Push notifications retry on failure (exponential backoff)

Semantic Kernel:

• Kernel factory produces consistent configuration
• All plugins expose typed function signatures
• HITL filter triggers for all mutating operations (SDS-031 §7)
• Audit filter logs all executions to observability pipeline
• Memory adapter successfully integrates with pgvector

Integration Tests

1
2
3
4
5
6
7
8
9
10
# Test A2A server with reference client
a2a-test-client --server http://localhost:8000 --test-suite basic

# Verify Agent Card discovery
curl http://localhost:8000/.well-known/agent.json | jq

# Send test task
curl -X POST http://localhost:8000/tasks \
  -H "Content-Type: application/json" \
  -d '{"message": {"role": "user", "parts": [{"text": "Analyze this code"}]}}'

Open Questions

Risks & Mitigation

Rollback Strategy

1. Disable A2A Gateway: Remove routes without affecting MCP or internal functionality.
2. Disable Delegation: Keep A2A server active but reject outbound client calls.

Related Documents

Linked Specifications

External References

User Review Required

[!IMPORTANT] Design Decision Required: This plan proposes REST as the MVP protocol binding. If you prefer JSON-RPC 2.0 (more aligned with MCP conventions) or gRPC (better streaming performance), please indicate before C2A begins.

[!WARNING] Breaking Change Consideration: Enabling the A2A Server allows external agents to invoke SEA™ capabilities. All incoming tasks will require HITL approval for mutating operations per SDS-031. Ensure appropriate approver availability before enabling in production.