Storing data in sub agents temporarily

[ManasaMedepalli]

This is what I am trying to do:
root agent sends user input to sub agent (exposed as Tool) -> Sub Agent does some calculations (let's call it 'sol' ) and returns plain text explaining saying it is done . Root agent has no idea of calculations done inside agentTool. Is there a way to temporarily store 'sol' data in the same session without using external storage like db or passing it as output_key? The agent tool should withhold this 'sol' data until a human feedback is sent (human->root->agent Tool) and then store it into db.
The whole point is to not let root agent know anything about what is happening inside sub agent tool.
Is this possible? how to do this?

[adk-bot]

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

TLDR: Yes, this is possible in ADK by creating a stateful tool. You can use the ToolContext object, which is automatically passed to your tool, to store and retrieve data from the session state. This keeps the data hidden from the root agent.

---

Hello! That's an excellent question about managing state within agents. You can definitely achieve the behavior you're describing. The key is to make your sub-agent (the tool) stateful.

In ADK, any tool can be designed to access and modify a persistent session state. This state is managed by ADK's SessionService and is scoped to the current conversation, making it perfect for your use case.

Here’s how it works:

1. Define Your Tool with ToolContext: If you define your tool as a Python function, make sure its last parameter is tool_context: ToolContext. The ADK runner will automatically detect this and pass in the context object during execution. [1, 2]

2. Use tool_context.state to Store Data: The tool_context.state attribute functions like a dictionary. You can write data to it in one turn, and that data will be available in subsequent turns within the same session. [1]

For your scenario, the implementation would look something like this:

• First Call (Calculation): The tool is called with the initial user input. It performs the calculation to get the result (sol), stores it in the session state (e.g., tool_context.state['solution'] = sol), and returns a generic message like "Calculation complete, awaiting feedback."

• Second Call (with Human Feedback): When the root agent calls the tool again with the human feedback, the tool can retrieve the stored data (sol = tool_context.state.get('solution')), perform the final database operation, and then clean up the temporary state (del tool_context.state['solution']).

This approach ensures that the root agent has no visibility into the solution data; it only ever sees the text inputs and outputs of the tool, preserving the encapsulation you want.

The ADK documentation has a great example of a stateful tool called get_weather_stateful that demonstrates this exact pattern of reading from and writing to tool_context.state. [1]

---

[1] Agent Teaming Tutorial
[2] Custom Tools