MCP vs A2A for the Heart Fleet (2026-10-17)

Verified distinction (A2A docs + Microsoft patterns + OpenCode MCP docs)

• MCP = vertical. How ONE agent reaches tools/resources (DB, API, filesystem, a service). Structured tool calls; the ORCHESTRATOR decides what tools to invoke and synthesizes the output. OpenCode natively supports it (local stdio + remote HTTP, OAuth).
• A2A = horizontal. How TWO agents cooperate as peers — discovery (Agent Cards), task contracts, shared long-running tasks with artifacts. The remote agent keeps its own chain-of-thought; tools/internals stay opaque to the caller.
• Doc sources agree: they're complementary, not competing. "Agents use MCP for their own tools; A2A for each other."

The decision for Heart Fleet (measured against our fleet)

A2A is our fleet's native transport — and it's already built and running. The fleet-ssh-tunnels registry maps every agent's A2A endpoint (16 forwards live as of 10-15); agents call each other as peers TODAY (Tam↔Min, Tam↔Sol… when endpoints are up). A2A is a one-line deploy for any Heart agent on any host (the agents-anywhere pack adds a tunnel row). Switching the fleet to MCP would throw away a working, proven, peer-to-peer transport built for exactly "Heart agents on any host".

MCP is the COMPLEMENT — keep it per-agent, for non-agent resources. When a Heart agent needs to read/prod Medusa Admin API, Postgres, O365 Graph, or the registry MCP (solos-registry, already enabled in my profile), OpenCode V2 gives us that in its mcp config (local/remote servers, per-agent enablement). That's the "tools" lane — not peer-agent traffic.

The rule (concise)

• Heart↔Heart, Heart↔Hermes, fleet coordination = A2A (our mesh tunnels; already working).
• Agent↔tool (Medusa/DB/O365/registry/filesystem) = MCP (inside each agent's own OpenCode config).
• Heart agent↔customer product (yukonit.com.au storefront chat, KB) = EVE native runtime, not A2A and not MCP — EVE agents are the product-side runtime (their own connections/ folder is the "tools lane" there).

When MCP even applies as "agent connect" — measured caveat

MCP servers CAN expose an agent as a "tool" (stateless/single-shot wrapper from Agent Card). Microsoft patterns + A2A docs both flag when each is right:

• Prefer MCP for: structured, stateless, tool-like access (query a report, fetch a fact, run one script).
• Prefer A2A for: peer collaboration, task delegation that may involve the other agent's reasoning/planning, multi-turn work, notifications, negotiation.
• Our fleet's use case is the second: "Ace, build this tenant spec" involves Ace's own planning and tools — not a stateless call.

Verified notes on OpenCode V2's MCP support (the "optimise" answer)

Confirmed from OpenCode V2 docs: mcp block in config with local (stdio) and remote (http/JSON) servers; per-agent tool enablement (glob patterns); OAuth flows; opencode2 mcp add/list/auth CLI. So Heart agents (running on Hermes profiles via OpenCode) can each have their own MCPs without touching A2A — the two layers coexist with ZERO conflicts (different concerns).

What we'd lose / gain if we forced fleet traffic onto MCP

• Lose: peer discovery (Agent Cards), task contracts (long-running multi-turn tasks), the working mapped-tunnel registry, Hermes's existing A2A server surfaces, the dashboard's endpoint monitoring.
• Gain: only the MCP tool-call CONTRACT (structured single-call model) — which we don't need for peer traffic and which breaks negotiation/delegation between agents.

Bottom line

A2A for fleet-to-fleet (what Heart Fleet means); MCP for fleet-to-tools (per-agent config). They're not alternatives — they sit at different layers, and OpenCode V2 supports both simultaneously in one config. Don't migrate the fleet; wire the tools lane per-agent when a specific need (Medusa/DB/O365) appears, per agent.

🎯 Tam's Read: A2A is the right protocol for Heart↔Heart/Hermes because that's what A2A IS (peer agents, task contracts, discovery) and ours is already built and running; MCP is the right protocol for each agent's own tools (Medusa/DB/registry) and OpenCode V2 natively hosts both layers in parallel — the "MCP vs A2A" question resolves to "use both, at their own layers."