When Agents Talk to Each Other: Hermes Speaks A2A

Single agents have gotten good at their one machine. The harder problem is what happens when you want a coding agent on a server to hand a task to a research agent across the building — without wiring them together by hand.

That's the gap the Agent2Agent (A2A) protocol was built to close. It started at Google, was donated to the Linux Foundation, and is now maintained by a steering committee that includes AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP, and ServiceNow. If MCP is the standard for an agent talking to a tool, A2A is the standard for an agent talking to another agent: opaque peers that discover each other, delegate tasks, and share results without exposing their internals.

The news for Hermes users is that the agent now speaks both roles of the protocol.

Your agent as a client

Turn on the a2a toolset and Hermes gains a handful of tools for reaching out. a2a_discover fetches and summarizes a peer's Agent Card — a JSON "digital business card" that lists an agent's identity, endpoint, capabilities, and skills, published in the standard spot at /.well-known/agent-card.json. a2a_call hands a peer a task and keeps a multi-turn conversation alive through a shared context_id. And a2a_orchestrate does the fun part: it fans a single request out to every peer that advertises a capability like web_search, in all, first, or best mode.

Configure known peers in config.yaml, point Hermes at any A2A endpoint, and you can ask a sentence like "Ask the researcher agent to summarize today's arXiv postings" — and the work happens off your local box.

Your agent as a service

The other half matters more for the long run. With the platform enabled, Hermes serves a real A2A endpoint: an Agent Card at /.well-known/agent-card.json advertising its name, skills, and auth requirements, plus a JSON-RPC 2.0 listener at POST / supporting the standard SendMessage, GetTask, ListTasks, CancelTask, and SubscribeToTask methods.

That means any A2A-compliant client — another Hermes, a LangChain or CrewAI agent, anything built on the official a2a-sdk — can treat your Hermes as a callable service. Your desktop agent can hand work to a Hermes on a server that has its own memory, tools, and credentials, and vice versa.

What stays yours

Two design choices keep this from becoming a free-for-all of agents calling agents.

First, the protocol is built on opacity: peers collaborate over HTTP(S) using JSON-RPC 2.0, and an operator never has to expose an agent's internal state, memory, or tools to get it to do useful work. Second, security is declared, not assumed — authentication requirements live in the Agent Card, and credentials travel through ordinary HTTP headers or bearer tokens you configure.

Hermes also keeps A2A in its lane. For multiple agents on the same machine, the docs point you to in-process delegation or the kanban board instead — A2A is deliberately scoped to crossing process, machine, and framework boundaries.

Why it matters

The agent ecosystem right now resembles the early web: walled, disconnected, and per-framework. A2A's bet is that agents should interoperate the way websites did, through open discovery and agreed contracts — with no shared runtime required. Hermes makes that bet concrete by working as both sides of the wire. Set up one peer, and your next research task can run on a different machine, in a different framework, written by a different vendor — and you barely need to know the difference.