Get root session or invocation id from agent called as tool (AgentTool)

[jimkont]

I am using Google ADK (Python) with a root LLM agent that invokes several other agents via AgentTool.

Each agent (root and sub-agents) exposes the usual callbacks:

• before_agent_callback
• after_agent_callback
• before_model_callback
• after_model_callback

Problem:
When an agent is invoked via AgentTool, ADK creates a new InvocationContext, and in some cases a new Session as well. As a result:

• CallbackContext.invocation_id changes between root agent and sub-agent
• CallbackContext.session.id may also change
• InvocationContext.branch is often empty (None) for agent-as-tool calls

This makes it difficult to associate callbacks of the agent-as-tool back to the root agent invocation, which is needed for cross-agent aggregation (e.g., metrics, cost attribution, request-scoped logging).

---

What I’m trying to achieve

Given a callback running inside an agent that was invoked via AgentTool, I want to reliably obtain:

• either the root agent invocation id, or
• a stable request identifier that is shared across the root agent and all nested agent-as-tool calls

So far, the following are not stable across agent-as-tool boundaries:

• CallbackContext.invocation_id
• CallbackContext.session.id
• InvocationContext.branch

---

Question

Is there a supported way in ADK to:

1. Access the root invocation context from within an agent invoked via AgentTool, or
2. Propagate a stable request / trace / correlation id across agent-as-tool calls, or
3. Retrieve the parent invocation id (or equivalent) in callbacks for agent-as-tool executions?

Any guidance on the intended ADK pattern for correlating agent-as-tool executions back to the root invocation would be appreciated.

[adk-bot]

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

TLDR: The recommended ADK pattern to correlate a sub-agent's execution back to its parent is to use the shared session.state dictionary. The root agent can write a unique correlation ID to session.state, which the sub-agent can then read.

---

Hello! Thank you for the detailed question. This is a common challenge when building complex, multi-agent systems.

You are correct that invoking an agent via AgentTool can create a new InvocationContext, which is why you're observing that invocation_id is not stable across this boundary.

The intended pattern in ADK for sharing information and correlating work between agents within the same session is to use the shared session.state object. This is a dictionary that persists across multiple turns and is accessible by all agents operating within that session. [1, 2]

Here is a step-by-step guide to achieve the correlation you're looking for:

1. Generate a Unique ID in the Root Agent: In one of your root agent's callbacks (e.g., before_agent_callback), generate a unique identifier for the top-level request.

   import uuid
   from adk.core import CallbackContext
   
   def before_agent_callback(context: CallbackContext):
       # Generate a unique ID if it's not already in the session state
       if 'root_correlation_id' not in context.session.state:
           context.session.state['root_correlation_id'] = str(uuid.uuid4())

2. Access the ID in the Sub-Agent: In the callbacks of your sub-agent (the one invoked by AgentTool), you can now reliably access this identifier from the session state.

   from adk.core import CallbackContext
   
   def my_sub_agent_callback(context: CallbackContext):
       # Access the root correlation ID from the shared session state
       root_id = context.session.state.get('root_correlation_id')
       if root_id:
           print(f"Sub-agent callback is running as part of root invocation: {root_id}")
           # Now you can use this ID for logging, metrics, etc.

This approach provides the stable "request identifier" you need to associate all nested agent work back to the original invocation. Direct access to a parent's invocation_id from a child agent is not a standard feature, as the framework favors using the shared session for this type of cross-agent communication.

I hope this helps you build your cross-agent aggregation and logging!

---

[1] Multi-agent systems (https://google.github.io/adk-docs/agents/multi-agents/)
[2] Build a team of agents (https://google.github.io/adk-docs/tutorials/agent-team/)