Automatic Localized Sessions between agents

[abi-jey]

Here is the scenario that I think should be supported by ADK:

Scenario

I have a Main agent and a sub-agent. I have an overall task that is given to the Main Agent, and I expect the Main Agent to break down this Task into Task 1, Task 2, and Task 3, then:

1. The Main Agent delegates Task 1 to the sub-agent, and gets its Result
2. The main agent delegates Task 2 to the sub-agent, but the sub-agent needs the context from Task 1 (Here, the main Agent must decide to provide context (Inefficient), or better, a session that exists from the conversation from Task 1)
3. The main agent delegates Task 3, but it's unrelated to the previous task. The main agent decides to create a new session.

Code example

sub_agent = Agent(
    name="SubAgent",
    model="gemini-2.5-pro",
    instruction=instruction,
    static_instruction=system_prompt,
    description=description,
    tools=tools,
)
    main_agent = Agent(
    name="MainAgent",
    model="gemini-2.5-pro",
    instruction=instruction,
    static_instruction=system_prompt,
    description=description,
    tools=AgentTool(sub_agent, session_persistance="dynamic"|"static"|"none"), # none would be corrent beahvoiur 
)

or

sub_agent = Agent(
    name="SubAgent",
    model="gemini-2.5-pro",
    instruction=instruction,
    static_instruction=system_prompt,
    description=description,
    tools=tools,
)
    main_agent = Agent(
    name="MainAgent",
    model="gemini-2.5-pro",
    instruction=instruction,
    static_instruction=system_prompt,
    description=description,
    tools=StatefulAgentTool(sub_agent, session_persistance="dynamic"|"static"), # exclude current impl.
)

Do you have similar use cases?
Did you go wrong in reading the ADK, and is there already documentation to orchestrate agents in the same manner?

Where is this helpful?

• Long-running complicated task, where an orchestration agent is needed, and a handoff causes confusion and does not help the User/Customer experience.

footnote: Also same can be implemented via a function tool

async def statefull_agent_as_tool(agent: Agent) -> Callable[[str, str, Optional[str]], Awaitable[Tuple[str, str]]]:
    """
    Wrap an agent as a tool, preserving its session state across invocations.
    """

    async def get_session(user_id: str, session_id: Optional[str]) -> Session:
        if session_id is None:
            session = await session_svc.create_session(app_name=agent.name, user_id=user_id)
            return session
        session = await session_svc.get_session(app_name=agent.name, user_id=user_id, session_id=session_id)
        session = cast(Session, session)
        return session

    async def sub_agent_call(request: str, your_name: str, session_id: Optional[str]) -> Tuple[str, str]:
        """
        A tool function that calls the agent with the given request, user name, and session ID.
        Returns the agent's response text and the session ID, allowing for stateful interactions.
        NOTE: If the Request is a new session_id should be None; if the query is part of an existing conversation, pass the session_id.

        Parameters:
            request(str): The request to send to the agent.
            your_name(str): The name of the user making the request.
            session_id(Optional[str]): The session ID to use for the agent session.
        Returns:
            Tuple[str, str]: A tuple, the first element is the agent's response text, the second element is the session ID.
        """

        session = await get_session(user_id=your_name, session_id=session_id)
        runner = Runner(
            app_name=agent.name,
            agent=agent,
            session_service=session_svc,
        )
        content = Content(
            role="user",
            parts=[Part(text=request)],
        )
        final_response = runner.run_async(
            user_id=your_name,
            session_id=session.id,
            new_message=content,
        )
        texts = []
        async for response in final_response:
            if response.is_final_response():
                logger.info("Received final response from sub-agent.")
            if not response.content or response.content.parts is None:
                logger.warning("Response content is None")
                continue
            part_texts = [part.text for part in response.content.parts if part.text]
            texts.extend(part_texts)
        return " ".join(texts), session.id

    return sub_agent_call

[abi-jey]

@adk-bot Can you give me a short short feedback?

[adk-bot]

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

TLDR: Your approach of wrapping the sub-agent in a custom function tool to manually manage its session is the correct and recommended way to achieve the dynamic, stateful interactions you've described.

---

Thank you for your detailed and insightful post. Your scenario for orchestrating a main agent and a stateful sub-agent is a powerful use case for building advanced agentic systems.

You are correct in your analysis. While ADK's AgentTool is designed for hierarchical agent delegation, it does not have a built-in parameter like session_persistance to dynamically control the sub-agent's conversational state across different calls.

The solution you've prototyped with your statefull_agent_as_tool function is an excellent example of how to leverage ADK's flexibility to implement this advanced pattern. By creating a custom FunctionTool, you gain explicit control over the sub-agent's lifecycle.

Your implementation correctly uses the SessionService to create or retrieve a session for the sub-agent based on a session_id [1, 2]. This gives the main agent the power to decide whether to continue a previous conversation with the sub-agent or start a new one, which is exactly the behavior you're looking for. This is a robust pattern for managing complex, multi-turn delegated tasks.

For more background, you can refer to the official documentation on how ADK handles Sessions and State, and how Tools can interact with this context [3, 4]. Your approach aligns perfectly with these fundamental concepts.

[1] Introduction to Conversational Context: Session, State, and Memory - https://google.github.io/adk-docs/sessions/
[2] Session: Tracking Individual Conversations - https://google.github.io/adk-docs/sessions/session/
[3] Tools in ADK - https://google.github.io/adk-docs/tools/
[4] Agent Team Tutorial (using Session State) - https://google.github.io/adk-docs/tutorials/agent-team/