How do I use ParallelAgent with shared state?

[NGC2336]

I need multiple sub-agents to read/write the same session state.
Is there a thread-safety guarantee in ADK?

[adk-bot]

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

diagnostic-check-ok — bot environment verified [test]

[adk-bot]

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

TLDR: ADK does not provide a built-in thread-safety guarantee for session state when modified by multiple sub-agents. You should use a locking mechanism to protect shared state or ensure sub-agents write to distinct state keys.

---

Hello! That's an excellent question about concurrency in ADK.

When using a ParallelAgent, all sub-agents share the same session.state. [2] If multiple sub-agents need to read and write to the same key in the session state, there is no automatic thread-safety guarantee, and you could encounter race conditions.

The documentation recommends that if you need to share a context between agents (as in a ParallelAgent), you must manage concurrent access carefully to avoid these issues, for example by using locks. [3]

There are two main approaches to handle this:

1. Use Distinct State Keys (Recommended)
The simplest way to avoid race conditions is to design your sub-agents to write to unique keys in the session state. For example, if you have two sub-agents, one could write to state['sub_agent_1_result'] and the other to state['sub_agent_2_result']. This avoids any conflict. [2, 5]

2. Implement Locking
If your sub-agents absolutely must read and write to the same key, you are responsible for implementing a locking mechanism. You can use Python's threading.Lock for this.

Here is a conceptual example:

import threading

# You would create a lock and make it available to your sub-agents,
# possibly by initializing it in a shared object or passing it during setup.
state_lock = threading.Lock()

def my_sub_agent_logic(session_state):
  # Acquire the lock before accessing the shared state
  with state_lock:
    # Safely read from and write to the shared state
    current_value = session_state.get('shared_key', 0)
    session_state['shared_key'] = current_value + 1

By using a lock, you ensure that only one sub-agent can modify the shared key at a time.

I hope this helps you build your solution!

[1] https://google.github.io/adk-docs/agents/workflow-agents/parallel-agents/
[2] https://google.github.io/adk-docs/agents/multi-agents/