Sub-Agent Usage in Multi-Agent System with `Agent.as_tool`

[ahouse73]

Please read this first

• Have you read the docs? Yes
• Have you searched for related issues? Yes

Question

TL;DR Can intermediate agents dynamically invoke their own tools/sub-agents during execution?

I am using the Agent SDK to develop a Multi-Agent System (MAS) and have implemented a hierarchical communication schema where agents delegate tasks to sub-agents. Each sub-agent is registered using Agent.as_tool, as I want the responses from sub-agents to be again utilized and no delegation of the task.

In my setup, I created a 3-level hierarchy:

1. Level 1: Delegation agent (agent1) delegates tasks based on user input.
2. Level 2: Translation agent (agent2), which should use its sub-agent tools for translation tasks.
3. Level 3: Spanish-speaking agent (agent3), responsible for translating text into Spanish.

However, when testing this hierarchy, it seems that agent2 does not utilize its own sub-agent (agent3). Instead, agent2 responds directly without invoking the tool (translate_to_spanish) provided by agent3.

Is this behavior expected? Am I missing something in how tools or delegation work within nested agents?

Minimal example

from agents import Agent, Runner
import asyncio

agent3 = Agent(
    name="Spanish agent",
    instructions="You only speak Spanish.",
)

agent2 = Agent(
    name="Translation agent",
    instructions=(
        "You are a translation agent. You use the tools given to you to translate."
        "If asked for multiple translations, you call the relevant tools."
    ),
    tools=[
        agent3.as_tool(tool_name="translate_to_spanish", tool_description="Translate the user's message to Spanish")
    ],
)

agent1 = Agent(
    name="Delegation agent",
    instructions="Handoff to the appropriate agent based of the task of the request.",
    tools=[
        agent2.as_tool(tool_name="translation", tool_description="Translate the users message to different languages")
    ],
)


async def main():
    r = await Runner.run(agent1, input="Say 'Hello, how are you?' in Spanish.")
    print(r.final_output)
    # ¡Hola! Estoy bien, gracias por preguntar. ¿Y tú, cómo estás?
    return r

r = await main()

Observed Behavior

For this example:

• The question is answered directly by agent2.

Expected Behavior

• I would expect agent2 to invoke its tool (translate_to_spanish) provided by agent3. However, this does not happen — even though both agents and their respective tools are properly configured.

I tried different prompts and configurations but consistently observed that intermediate agents (e.g. agent2) do not utilize their own sub-agents/tools.

Any guidance or clarification regarding multi-agent delegation and tool invocation would be greatly appreciated!

[seratch]

Hi @ahouse73, thanks for asking the question. I ran your code example and it worked as expected. I ran it several times but I couldn't see the situation you've observed.

That said, the current instructions you have in the code are relatively simple. So, the set of the agents could behave differently. To prevent it, you can 1) enrich the instructions even more clearly tell what and when the tools must be used and/or 2) have model_settings.too_choice = "required": https://openai.github.io/openai-agents-python/agents/#forcing-tool-use

Hope this helps.

[ahouse73]

Hi @seratch. Thank you for the quick response!

I initially thought the behavior wasn’t working as intended because there are only 3 items in the RunResult.new_items:

1. A ToolCallItem for invoking the "Translation" agent,
2. A ToolCallOutputItem for the output from the "Translation" agent,
3. A MessageOutputItem for the final response to the user.

I expected an additional ToolCallItem representing a call to the "Spanish" agent.

Would using Spans and Traces be the best way to track and debug how agents communicate internally?

[seratch]

The reason why agent3's interactions are not included in agent1's conversation is that agent3's model interactions are separate from agent1's interactions with Responses API.

The tracing dashboard captures the entire workflow execution by sending tracing data for each event. So, as you said, I'd suggest checking the dashboard or enabling debug logs (DEBUG=* is the quickest way to print debug logs).

Hope this helps!

[ahouse73]

Thank you for the reply, that definitely clarifies things.

Unfortunately, I don’t have access to the OpenAI Tracing Dashboard, so I will look for an alternative solution. Are all necessary details typically stored in the Spans/Traces, and would this be the best approach to gather relevant information?

[seratch]

Yes, it would. Also, if you have a different monitoring tool in hand, sending the tracing data to 3rd party platforms listed here would be an option too.

Thanks for asking the question! Let me close this issue now, but if you have anything further, please feel free to add comments at any time!