How to pass the session information to remote a2a agent

[ShyamGurunath]

I wanted to share the session from my root agent to sub agents. Im building a mutliagent system where a supervisor hands off to multiple remote sub agents. Whenever the supervisor creates the adk sessions is not passed to the subagents so the sub agents doesn't know what's happening perviously.

[ShyamGurunath]

@adk-bot can you please help

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: You don't pass the session object directly to remote agents. Instead, the supervisor agent should extract the necessary data from its session state and pass that data as arguments when calling the remote agent. The remote agent then uses this data within its own, separate session.

---

Hello! That's a great question about architecting a multi-agent system with ADK.

There's a key distinction in how session information is shared between agents running in the same process versus agents running remotely.

1. Local Sub-Agents (Same Process)

When you have a parent agent that orchestrates sub-agents locally (e.g., using SequentialAgent or ParallelAgent), they all operate within the same InvocationContext. This means they naturally share the same session object. You can easily pass data between them using the shared session state. [1, 2]

For example:

• Agent 1 (Supervisor): context.session.state['shared_data'] = "some important info"
• Agent 2 (Sub-agent): important_info = context.session.state.get('shared_data')

2. Remote Sub-Agents (Agent-to-Agent - A2A)

For remote agents, the architecture is different. The ADK provides the Agent-to-Agent (A2A) communication protocol for this purpose. You would expose your sub-agents as an A2AServer and the supervisor would interact with them using a RemoteA2aAgent. [3]

In this model, the remote agent is treated like a tool. The supervisor doesn't share its entire session object. Instead, the correct pattern is:

1. Extract Data: The supervisor gathers the necessary information from its own session state (e.g., conversation history, user ID, relevant facts).
2. Pass as Arguments: The supervisor invokes the RemoteA2aAgent and passes the extracted data as part of the prompt or arguments.
3. Execute Remotely: The remote agent receives this data in its run method, performs its task (potentially creating and managing its own session on its server), and returns a result.

Here is a conceptual example of how the supervisor might work:

# In your supervisor agent's code
from google.adk.agents import InvocationContext, RemoteA2aAgent

async def run(self, context: InvocationContext):
    # 1. Get relevant history from the supervisor's session state.
    conversation_history = context.session.state.get("history", [])
    user_request = context.get_last_user_content()

    # 2. Format the data and pass it as an argument to the remote agent.
    # The RemoteA2aAgent is configured to connect to your remote sub-agent's server.
    result = await self.invoke_sub_agent(
        "my_remote_sub_agent", # The name of the RemoteA2aAgent instance
        f"Given this history: {conversation_history}, please handle this request: {user_request}"
    )

    # 3. Use the result from the remote agent.
    response_text = result.content.parts[0].text
    # ... create and return a final response

This approach ensures that your agents are self-contained and communicate through well-defined interfaces, which is a robust pattern for building distributed multi-agent systems.

---

[1] Session State Documentation
[2] Multi-Agent Orchestration
[3] Agent-to-Agent (A2A) Communication

[seanzhou1023]

@ShyamGurunath thank you for reaching to us. please ignore the bot answer above. session is just a place where historical events and state are saved in ADK. two agents are not sharing the session but share the context. we already send historical events information as context to remote subagent :

adk-python/src/google/adk/agents/remote_a2a_agent.py

Line 354 in 6b49391

def _construct_message_parts_from_session(

you should not worried about the context.