ADR-038: A2A Protocol & Semantic Kernel Integration Architecture

Status: Accepted Version: 1.0 Date: 2026-01-02 Supersedes: N/A Related ADRs: ADR-017 (MCP-LSP Integration), ADR-032 (NATS JetStream), ADR-033 (Kernel-Shell) Related PRDs: PRD-027

[!NOTE] Implementation Details: The technical specifications for this architecture are in:

• SDS-056: A2A Protocol Gateway — A2A server/client adapters
• SDS-057: Semantic Kernel Orchestration — Internal agent orchestration

This ADR remains the authoritative architectural decision; the SDS documents provide implementation details.

Context

SEA-Forge™ agents currently communicate via:

• LSP for IDE intelligence (hover, diagnostics, code actions)
• MCP for agent-to-tool capabilities (semantic probes, safe tool surface)

However, there is no standardized way for SEA™ agents to:

1. Communicate with external AI agents built on different frameworks (LangGraph, CrewAI, Google ADK)
2. Orchestrate complex internal workflows with memory, planning, and plugin execution
3. Expose capabilities for discovery by external systems

Industry Context:

• A2A (Agent-to-Agent Protocol) — Open standard from Google/Linux Foundation for inter-agent communication
• IBM ACP — Merged into A2A as of March 2025
• Semantic Kernel — Microsoft’s OSS SDK for building AI agents with plugins, planners, and memory

Protocol Relationship

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
┌─────────────────────────────────────────────────────────────┐
│                     SEA™ Agent Runtime                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────────┐   ┌─────────────┐   ┌─────────────┐      │
│   │    MCP      │   │     A2A     │   │  Semantic   │      │
│   │ (Tools)     │   │  (Agents)   │   │   Kernel    │      │
│   └──────┬──────┘   └──────┬──────┘   └──────┬──────┘      │
│          │                 │                 │              │
│          └────────────┬────┴─────────────────┘              │
│                       │                                     │
│              ┌────────▼────────┐                            │
│              │   Kernel Core   │                            │
│              │  (SDS-031/055)  │                            │
│              └─────────────────┘                            │
└─────────────────────────────────────────────────────────────┘

Protocol Purposes:
- MCP:    Agent ↔ Tool     (how agents use capabilities)
- A2A:    Agent ↔ Agent    (how agents collaborate)
- SK:     Internal Orchestration (workflows, memory, plugins)

Decision

Integrate A2A Protocol and Microsoft Semantic Kernel to enable SEA™ agents to:

1. Receive tasks from external agents via A2A Server
2. Delegate tasks to external agents via A2A Client
3. Orchestrate internal workflows via Semantic Kernel
4. Expose capabilities via A2A Agent Card (derived from SK plugins)

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
External Agents                    SEA™ Agent Runtime
     │                                    │
     │  A2A Protocol                      │
     │  (REST/JSON)                       │
     ▼                                    ▼
┌─────────────────────────────────────────────────────────────┐
│                   A2A Protocol Gateway                       │
│  ┌─────────────────────┐  ┌─────────────────────┐           │
│  │    A2A Server       │  │    A2A Client       │           │
│  │  (Receive Tasks)    │  │  (Delegate Tasks)   │           │
│  └──────────┬──────────┘  └──────────┬──────────┘           │
└─────────────┼────────────────────────┼──────────────────────┘
              │                        │
              ▼                        ▼
┌─────────────────────────────────────────────────────────────┐
│                  Semantic Kernel Runtime                     │
│  ┌───────────────┐  ┌─────────────┐  ┌─────────────────┐    │
│  │    Plugins    │  │   Filters   │  │     Memory      │    │
│  │  (Capabilities)│  │ (Governance)│  │  (pgvector)     │    │
│  └───────────────┘  └─────────────┘  └─────────────────┘    │
│           │                │                   │             │
│           └────────────────┼───────────────────┘             │
│                            ▼                                 │
│                   ┌────────────────┐                         │
│                   │  Kernel Core   │                         │
│                   │  (Execution)   │                         │
│                   └────────────────┘                         │
└─────────────────────────────────────────────────────────────┘
              │                        │
              ▼                        ▼
┌─────────────────────────────────────────────────────────────┐
│                 Existing Infrastructure                      │
│  ┌─────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
│  │  MCP Tools  │  │  NATS JetStream │  │  Observability  │  │
│  │  (SDS-052)  │  │    (SDS-047)    │  │    (SDS-030)    │  │
│  └─────────────┘  └─────────────────┘  └─────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Technology Choices

A2A Agent Card

SEA™ agents are discoverable via A2A Agent Card at /.well-known/agent.json:

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
{
  "name": "sea-forge-agent",
  "version": "1.0.0",
  "description": "SEA-Forge™ semantic engineering agent",
  "url": "https://sea.example.com",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {
      "id": "semantic-analysis",
      "name": "Semantic Code Analysis",
      "description": "Analyze code semantics using LSP intelligence"
    },
    {
      "id": "artifact-generation",
      "name": "Artifact Generation",
      "description": "Generate CADSL diagrams and documentation"
    }
  ],
  "authentication": {
    "schemes": ["bearer"]
  }
}

Semantic Kernel Governance

All SK executions pass through governance filters per SDS-031:

1
2
3
4
5
6
7
8
# Filter execution flow
@kernel.filter(FilterTypes.FUNCTION_INVOCATION)
async def hitl_filter(context: FunctionInvocationContext, next):
    if context.function.metadata.get("requires_approval"):
        approval = await request_hitl_approval(context)
        if not approval.granted:
            raise HITLRejected(approval.reason)
    return await next(context)

Rationale

Why A2A?

• Industry Standard: Google + Linux Foundation backing; ACP merged in
• MCP Complementary: A2A handles agents, MCP handles tools
• Framework Agnostic: Works with LangGraph, CrewAI, Google ADK, etc.
• Enterprise Ready: OAuth 2.0, streaming, push notifications

Why Semantic Kernel?

• Plugin System: Clean abstraction for SEA™ capabilities
• Filter System: Pre/post hooks for governance (HITL, audit)
• Memory Integration: Built-in vector memory support
• Planner: Automatic function orchestration for complex goals
• Active Development: Microsoft-backed, growing ecosystem

Alternatives Considered

LangGraph Only

Rejected — Great for graph-based agents but lacks:

• Built-in plugin system for capability exposure
• Filter system for governance hooks
• Native memory integration

Custom Agent Framework

Rejected — NIH problem; requires significant development and maintenance.

A2A Without Semantic Kernel

Rejected — A2A handles communication but not internal orchestration.

Constraints

A2A Protocol

• MUST implement A2A REST binding for MVP
• MUST serve Agent Card at /.well-known/agent.json
• MUST support task lifecycle states (submitted, working, input-required, completed, failed, canceled)
• MUST implement streaming via SSE
• MUST support push notifications via webhooks

Semantic Kernel

• MUST use Python SDK (user confirmed)
• MUST expose plugins that map to Agent Card skills
• MUST implement HITL filter for mutating operations
• MUST implement audit filter for all executions
• MUST integrate with pgvector for memory

Governance

• MUST enforce SDS-031 authority boundaries
• MUST require HITL approval for external task mutation
• MUST emit semantic observability events (SDS-030)
• MUST NOT auto-execute mutating operations from external agents

Quality Attributes

• Interoperability: SEA™ agents can collaborate with any A2A-compliant agent
• Extensibility: New capabilities added as SK plugins
• Governance: All operations pass through HITL and audit filters
• Observability: Full tracing across A2A → SK → execution

Bounded Contexts Impacted

• sea-api: A2A HTTP routes
• agent-runtime: Semantic Kernel integration
• shared/governance: SDS-031 extensions for agent delegation

Consequences

Positive

• External agent interoperability
• Standardized capability exposure
• Governed agent orchestration
• Memory-enhanced agent workflows
• Industry-standard protocols

Negative

• Additional infrastructure complexity
• A2A spec is draft (v1.0) — may evolve
• Python dependency for Semantic Kernel
• Network latency for external agent calls

Implementation Plan

See P027: A2A Protocol & Semantic Kernel Integration

Additional Notes

External References