What A2A is

Agent-to-Agent is a spec for an agent to discover, negotiate with, and delegate to another agent. Not the agent-calls-tool pattern (that’s MCP). The agent-calls-agent pattern.

The shape:

• Agent cards. Each agent publishes a manifest describing what it does, what inputs it expects, what guarantees it offers (latency SLO, cost, supported languages).
• Discovery. A registry of agent cards (think DNS for agents).
• Negotiation. A calling agent asks “can you handle X?”; the called agent says yes/no, with terms.
• Delegation. The calling agent passes the task to the called agent; the called agent owns the work until it returns a result.

Why this matters

Tool calling is request/response. A2A is fire-and-forget delegation — the called agent might take seconds, minutes, or hours. The protocol handles the asynchrony.

For Genie:

• financial_supervisor (the coordinator) delegates kyc_orchestrator to handle a KYC subtask asynchronously. Today this is bus-based with custom message types. With A2A it’s a standard protocol — and the same kyc_orchestrator can be called by external agent ecosystems.

What the Go client looks like

import "github.com/anthropics/a2a-go"  // hypothetical

client := a2a.NewClient(a2a.Config{
    AgentID: "financial_supervisor",
})

// Discover an agent
target, err := client.Discover(ctx, "kyc.decide")
if err != nil { return err }

// Negotiate
terms, err := client.Negotiate(ctx, target, a2a.Terms{
    MaxLatency: 30*time.Second,
    MaxCost:    1000,  // micros
})

// Delegate
result, err := client.Delegate(ctx, target, kycPayload)

The Genie pattern wraps this so the orchestrator’s policy stack (RBAC, tenant, classification) still runs before any A2A call — the policies don’t change because the transport did.

What this enables

Cross-org agent ecosystems. A bank’s KYC agent can be called by a fintech’s onboarding agent (with mutual SPIFFE-based authentication and a signed terms agreement). The fintech doesn’t have to bundle the bank’s KYC stack; the bank doesn’t have to expose APIs the fintech maintains. Both sides agree on the A2A protocol.

This is what makes the “ecosystem of agents” vision materially different from “ecosystem of microservices.” Microservices need shared infra and contracts. Agents need shared protocol; the contracts are negotiated per-call.

Status of the spec

A2A is still emerging. The spec is stabilising; implementations are appearing; production deployments are sparse. For Genie, the position is: design for it, ship MCP first (more mature), add A2A when the customer asks for it.

When does a customer ask? Usually when they have multiple in-house agent systems they want to interconnect, or when they want to consume someone else’s agent without reimplementing.

The protocol is short. The conceptual shift — “agents are first-class peers, not tools” — is the larger change.