Asim Aslam
307b94aab7
* feat(a2a): Agent2Agent protocol gateway Add gateway/a2a — exposes registered agents over the open A2A protocol so agents on other frameworks can discover and call them. Agent Cards are generated from registry metadata (the same way the MCP gateway derives tools from service endpoints); incoming A2A tasks translate to the agent's existing Agent.Chat RPC, so there's no per-agent code. v1 is the synchronous JSON-RPC binding: message/send returns a completed Task, tasks/get retrieves it, and Agent Cards are served for discovery; streaming and push notifications are advertised as unsupported. Run with 'micro a2a serve' (cmd/micro/a2a). Tests cover card generation, message/send, tasks/get, listing, and unknown-method errors. * docs: A2A guide, README contents + A2A section, universe A2A check - Add a Contents table of contents at the top of the README and an A2A subsection under Building Agents. - Add the Agent2Agent (A2A) guide and register it in the docs nav. - Exercise the A2A gateway in the universe harness: the concierge agent is reached over A2A (message/send -> Agent.Chat -> completed task). * feat(a2a): outbound client — call external A2A agents Add a2a.Client (Send/Card) so a Go Micro agent or flow can call an agent on any framework by URL — the outbound counterpart to the gateway. Wired in two places: flow.A2A(url) as a workflow step (the cross-framework Dispatch), and agent delegate to an http(s) URL routes over A2A. The universe harness now drives the gateway through the client, exercising both directions. Tests cover client send/card and the round trip. * docs: A2A both-directions — guide, README, changelog, blog #26 --------- Co-authored-by: Claude <noreply@anthropic.com>
3.5 KiB
layout, title, permalink, description
| layout | title | permalink | description |
|---|---|---|---|
| blog | Agents Across Frameworks: A2A | /blog/26 | Go Micro agents already call each other over RPC. Now they speak the Agent2Agent protocol too — reachable by, and able to reach, agents built on any framework. Cards are generated from the registry, the same way the MCP gateway derives tools. |
Agents Across Frameworks: A2A
June 18, 2026 • Asim Aslam
Inside a Go Micro system, agents already talk to each other. An agent is a service with an Agent.Chat endpoint, so delegate just calls another agent over RPC. That works as long as everyone is on Go Micro. The moment an agent is built on a different framework, the conversation stops: it can't call yours, and yours can't call it.
A2A — the open Agent2Agent protocol — is the standard that closes that gap, and Go Micro now speaks it.
A2A is to agents what MCP is to tools
This lines up with something Go Micro already does. The MCP gateway exposes your services as tools to any MCP-speaking agent. The A2A gateway exposes your agents as agents to any A2A-speaking client. Two interop standards, two front doors — and now both are covered.
The design is the same in both cases: discovery is generated from the registry. MCP derives a tool from each service endpoint. A2A derives an Agent Card — the JSON descriptor other agents read to find and call yours — from each agent's registry metadata. There is nothing to publish and no code to add. Register an agent, and it has a card:
micro a2a serve --address :4000
micro a2a list
An incoming A2A task is translated to the agent's existing Agent.Chat RPC — the same call delegate and flows already use. The agent's loop, memory, guardrails, and tool wrappers all apply unchanged. The gateway is a protocol adapter, not a second agent runtime.
Both directions
Exposing your agents is half of it. The other half is calling agents that aren't yours. The a2a.Client does that, by URL, and it's wired into the two places work gets handed off:
// As a workflow step — the cross-framework counterpart to Dispatch:
flow.Step{Name: "research", Run: flow.A2A("https://other.example.com/agents/research")}
// From inside an agent, delegate to a URL and it goes over A2A:
// "delegate this to https://other.example.com/agents/research"
When delegate's target is an http(s) URL instead of a local agent name, the subtask is sent over A2A. The model doesn't learn a new tool; it just delegates to a URL.
Scope
This is the synchronous JSON-RPC binding: message/send runs the agent and returns a completed task, tasks/get retrieves one, and Agent Cards are served for discovery. Streaming (message/stream), multi-turn input-required, and push notifications are advertised as unsupported on the card, so clients negotiate correctly. Those are the follow-ups; the synchronous binding is what makes a Go Micro agent both reachable from, and able to reach, the wider ecosystem today.
Where it fits
A2A completes the interop set. MCP exposes services as tools, A2A exposes agents as agents, and x402 handles payment between them — all derived from the registry, none of them a new runtime. An agent stays a service; A2A is one more way to reach it, alongside the Chat RPC, micro chat, and a flow. Building an agent that the rest of the world can talk to is, again, building a service.
See the A2A guide for the full reference.