September 12, 2025, 1:19pm 1

Motivation

LangGraph currently supports MCP adapters via langchain-mcp-adapters, which allow external tools to be integrated as @tools.

However, in many cases external systems are not just tools but full agents — capable of reasoning, maintaining state, and returning structured results.

The emerging Agent-to-Agent (A2A) protocol provides a standard for communication between such agents. Supporting A2A natively in LangGraph would allow users to seamlessly add remote agents as first-class nodes/sub-graphs.

Problem

• Today, connecting to a remote agent requires custom handoff implementations (handoffs guide) or custom commands.

• This is not ergonomic, and doesn’t fully capture the semantics of stateful remote agents.

• Users should be able to declare remote agents just as easily as they do with tools.

Proposed Solution

Introduce a new concept of RemoteAgentNode (similar to ToolNode), backed by an A2A adapter/client.

Prototype Architecture

• RemoteAgent: Represents a remote agent endpoint.

• RemoteAgentNode: Wraps RemoteAgent for integration into LangGraph execution.

• A2AClient: Handles transport and protocol translation.

Message Flow:
LangGraph (handoff)
↓
RemoteAgentNode.run()
↓
RemoteAgent.call()
↓
A2AClient.send()
↓
[A2A protocol transport: HTTP/WebSocket/gRPC/etc.]
↓
Remote Agent
↓
Response (state update)
↓
RemoteAgentNode returns to LangGraph

To keep scope small, the first PR could implement:

1. RemoteAgentNode with blocking handoff only

   • Synchronously send state → wait for full response → return to LangGraph.

   • No streaming, concurrency, or advanced orchestration.

2. Minimal A2AClient abstraction

   • Just use HTTP transport with JSON payloads (later pluggable for WebSocket/gRPC).

3. Simple Example Notebook

   • One remote agent integrated into a LangGraph, demonstrating a blocking handoff.

This keeps the first PR low-risk, reviewable, and easy to merge.
Future PRs can then add streaming, concurrent orchestration, memory federation, etc.

Extensions

• Streaming support: Pass remote agent’s token/thought stream back into LangGraph channels.

• Memory federation: Allow sharing of selected history/state with remote agents.

• Parallel orchestration: Enable multiple remote agents to run concurrently as graph branches.

My understanding is that A2A endpoint allows the agents to send/receive messages, it does not share the state. So the remote agent is not first-class nodes/sub-graphs as mentioned in the original feature request.

Can you comment if above understanding is correct?

Any there plans to implement the original feature request?

1 Like