Recently there are some news in the AI industry, that sounded like the agent to agent, communication or harness to harness communication is getting really important as systems getting more complex. One agent cannot handle everything and it initiate the need for one agent to communicate with other agent somehow, Google spotted this well in advanced and released Agent2Agent(A2A) protocol and donated to the Linux foundation as an open source protocol however, protocol didn’t took off because there was no real use cases up until now to make the real impact. Now, it seems, things are changing recently as work getting more complex and coding agents and models are getting more capable. In this post we will cover what are the recent trends happening in the industry that needed agent to agent, communication, and how industry is silently building into agent communication without explaining or courting the agent to agent protocol.
What’s new in Claude: Managed Agents & Parallel Sessions
Anthropic just launched cross-session messaging in Claude Code. Sessions can now exchange messages directly. Basically one session can communicate with other session. One session discovers another by name, sends a plain-text summary, and receives a reply without the human acting as relay. The same mechanism supports agent teams, where teammates write to each other’s mailboxes implemented as JSON files under a shared teams directory with automatically delivery. The documentation for cross-session messaging and agent teams describes stable names, inbox sockets or server-mediated paths, rate limits that prevent loops, and a clear distinction between user input and inter-agent traffic.
Claude Managed Agents supports a related pattern. A coordinator spawns specialists that share a sandbox and filesystem while keeping separate session threads and histories. Events such as thread message received and thread message sent make the coordination visible. The platform documentation shows persistent threads and the ability for the coordinator to follow up with an agent that retains its earlier context.
These capabilities improve parallelism and isolation inside a single product. They also expose a recurring design choice. Messaging remains an internal harness detail. A recent issue in the Claude Code repository noted that multi-agent setups routinely invent their own message bus on the filesystem, complete with improvised identifiers, forced check-in intervals, and external heartbeats because writing a file does not wake a recipient. The missing properties are stable addressability, reliable delivery, wake-on-arrival, and observable consumption.
Agent2Agent(A2A) Protocol:Horizontal Counterpart to MCP
An open protocol already defines those properties. The Agent2Agent (A2A) protocol, introduced by Google and now hosted by the Linux Foundation, provides Agent Cards served at a well-known location that advertise identity, skills, authentication schemes, and interface endpoints. Tasks form the unit of work. They carry lifecycle state, support streaming, and can remain open for extended periods. Communication stays opaque: the calling side never requires the remote agent’s tools, memory, or runtime. The original announcement and subsequent ecosystem growth are documented in the A2A repositories and the Python SDK.
A2A was framed from the start as the horizontal counterpart to the Model Context Protocol. MCP standardizes how an agent reaches tools and data. A2A standardizes how one agent reaches another agent. Recent work on MCP Server Cards under the Server Card working group follows a similar discovery pattern: a static metadata document that lets clients inspect transport, authentication, and capability information before connecting. The shapes are aligning even while explicit discussion of agent-to-agent contracts remains quieter than the volume of multi-agent feature releases. MCP also planning something called tasks for the longer running session and agent to agent communication in the near future which sounds like the replica of the A2A or same features that A2A already provides.
Private Implementation of A2A Inter-Agent Traffic
Most companies and products coming to market continue to treat inter-agent traffic as private implementation and they rarely mentioned the A2A protocol. Claude Code uses file mailboxes and sockets. Other harnesses rely on shared directories, custom queues, or framework-specific event buses. Each team re-solves identity, delivery semantics, presence, acknowledgement, and security boundaries. Composition across vendors or harnesses stays difficult because no shared contract exists for discovery or task lifecycle.
Our own tool SuperQode took different approach. The earlier post on SuperQode A2A described an A2A surface that exposes SuperQode harnesses as callable peers. Clients read the public Agent Card, submit tasks over the advertised interface, and receive structured results while SuperQode keeps its own evidence ledger and execution policy. A2A owns discovery and task lifecycle. The harness owns policy, tools, evaluation, and durable records. Neither side needs a shared language runtime or monorepo. The same boundary lets systems such as YC’s QM hand off constrained coding work without absorbing SuperQode’s internals.
Will industry Adopt A2A as Standard or Work Independently
Internal multi-agent coordination inside one product is valuable but It does not solve composition across organizational or vendor lines. Open agent-to-agent protocols badly needed to solve this problems. They turn harnesses and specialist agents into addressable objects that can be discovered, authenticated, and tasked without custom integration for every pair.The protocol already exists. Complementary card-based discovery is appearing on the MCP side and other initiatives may land soon. The remaining gap is the decision to treat agent-to-agent communication as a first-class contract rather than an internal mailbox. Teams that make that decision early will compose specialists the way current systems compose tools. Others will keep re-implementing the same delivery guarantees on disk or their own way.
The practical steps are limited right now. Publish an Agent Card and then implement the task lifecycle Keep evidence and policy on the harness side and test against independent clients written in different languages. The wire format is already defined. The engineering work is to treat the boundary as a contract instead of an afterthought. This space is getting interesting and we couldn’t resist to write about it, for now A2A seems to great choice for th Agent to Agent communication and we are sticking to it.
The A2A specification and repositories, the Python SDK, and the SuperQode implementation in the main repository provide concrete starting points. The Claude Code documentation on cross-session messaging and agent teams shows the private-messaging pattern that open protocols are intended to replace at larger scale.