[BUG] parallel_tools aren't truly parallel

[namartaknev]

Checks

• I have updated to the lastest minor and patch version of Strands
• I have checked the documentation and this is not expected behavior
• I have searched ./issues and there are no duplicates of my issue

Strands Version

0.1.7

Tools Package Version

0.1.5

Tools used

1. Custom tool 1
2. Custom tool 2
3. Custom tool 3

Python Version

3.11.12

Operating System

macOs

Installation Method

pip

Steps to Reproduce

1. Created a custom class named StrandsSupervisorAgent with the configuration

            # Prepare tools list
            tools = [
                classifier,
                call_agent_1,
                call_agent_2,
                call_agent_3,
                call_agent_4,
                current_time
            ]

             self.agent = Agent(
                max_parallel_tools = 5,
                tools=tools,
                model=bedrock_model,
                system_prompt=system_prompt
            )

2. Can have custom tools that make API calls/Bedrock invocation.
3. Supervisor system prompt includes instructions to make parallel calls to call_agent_2, call_agent_3 and call_agent_4.
4. Observing the logs of each tool calls - its is evident that the calls are sequential and not parallel as they appear in different times one after the other.

Expected Behavior

parallel tool call must be truly parallel - should be executing around the same timestamp and process in parallel

Actual Behavior

In the logs I can see the supervisor determining to make parallel calls

[2025-06-17 00:45:52] DEBUG: 🔧 Tool use tracked: call_bedrock_agent (ID: tooluse_wu1R8P_GRCSOH31ufZHanA)
[2025-06-17 00:45:54] DEBUG: 🔧 Tool use tracked: call_bedrock_agent (ID: tooluse_aoHCISAvTsqjJnT4fdhhqg)
[2025-06-17 00:45:55] DEBUG: 🔧 Tool use tracked: call_bedrock_agent (ID: tooluse_aEVgjOsBTB2_jvqJkTq61g)

Additional Context

No response

Possible Solution

No response

Related Issues

Internal ticket id: V1822332014

[zastrowm]

What model and system-prompt are you using? If I recall correctly, some models are very difficult to actually convince to use parallel tool calling. Anthropic had a note about this for 3.7: https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use#parallel-tool-use - I believe this was one of the motivating factors for the batch tool.

If I try a barebones implementation, this seems to run tools in a parallel:

from datetime import datetime
import time
from strands import Agent, tool

@tool
def try_in_parallel(i):
    """
    Test function to verify parallel tool calling

    Args:
        i: An index indicating which function invocation this is
    """

    print(f"{i} Start {datetime.now()}")
    time.sleep(5)
    print(f"{i} End {datetime.now()}")

    return "done"

# Prepare tools list
tools = [
    try_in_parallel
]

system_prompt = """
ALWAYS call all tools in parallel
"""

agent = Agent(
    max_parallel_tools = 5,
    tools=tools,
    system_prompt=system_prompt
)

agent("Call try_in_parallel 5 times in parallel")

Output:

I'll call the `try_in_parallel` function 5 times in parallel for you.
Tool #1: try_in_parallel

Tool #2: try_in_parallel

Tool #3: try_in_parallel

Tool #4: try_in_parallel

Tool #5: try_in_parallel
1 Start 2025-06-24 15:04:51.981069
2 Start 2025-06-24 15:04:51.981241
3 Start 2025-06-24 15:04:51.981366
4 Start 2025-06-24 15:04:51.981628
5 Start 2025-06-24 15:04:51.981862
2 End 2025-06-24 15:04:56.9860853 End 2025-06-24 15:04:56.986402
4 End 2025-06-24 15:04:56.986476

1 End 2025-06-24 15:04:56.986533
5 End 2025-06-24 15:04:56.986582
I've successfully called the `try_in_parallel` function 5 times in parallel. Each call was completed with the result "done".

[zastrowm]

There is an AI here that we should have an integration test verifying this behavior

[namartaknev]

I used claude 4o. I see the model dispatches the tool calls - for example, i was able to see debug logs like
[2025-06-19 19:51:35] DEBUG: 🔧 Tool use tracked: call_agent_1 (ID: tooluse_G1D0daRjStisgkJHavngug)
[2025-06-19 19:51:36] DEBUG: 🔧 Tool use tracked: call_agent_2 (ID: tooluse_mfLIs7b8TiifSUrtbvM-gQ)
[2025-06-19 19:51:36] DEBUG: 🔧 Tool use tracked: call_agent)3 (ID: tooluse_f4pSBBTZSa2upH1l1ghiwQ)

However, in telemetry, i can see those individual tool calls were sequential and were waiting one after the other.
One way of how I could move forward with making these truly parallel was

_bedrock_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=20)

@tool
def call_agent_1_threaded(query: str) -> str:
    """Threaded version of account agent call"""
    future = _bedrock_thread_pool.submit(_call_bedrock_agent_sync, "agent1", query)
    return future.result()  # This will block until complete, but other tools can start

@tool  
def call_agent_2_threaded(query: str) -> str:
    """Threaded version of revenue agent call"""
    future = _bedrock_thread_pool.submit(_call_bedrock_agent_sync, "agent2 query)
    return future.result()
.
.
.

[zastrowm]

@namartaknev that seems to indicate that the tools themselves are parallel but that Bedrock itself is running requests sequentially?

Are you using different sessions per thread tool? I wonder if something with boto3 is locking when running across threads. Per the docs:

Similar to Resource objects, Session objects are not thread safe and should not be shared across threads and processes. It's recommended to create a new Session object for each thread or process

And we're actually using the same mechanism in strands that you used for bedrock which makes me wonder if it's bedrock specific: https://github.com/strands-agents/sdk-python/blob/b3890bb83821fe9cf3a0940ed79c75378e239811/src/strands/tools/executor.py#L87