Error: “Function transfer_to_agent is not found in the tools_dict” when sub-agent invokes another agent inside LoopAgent

[parthiaitech]

Hi team,

I’m experimenting with a multi-agent workflow in Google ADK where a main (supervisor) agent coordinates several sub-agents, including a LoopAgent that handles iterative planning and execution.

Here’s the simplified structure:

loop_agent = LoopAgent(
name="loop_agent",
sub_agents=[planner_agent, executor_agent],
max_iterations=20
)

SupervisorAgent = LlmAgent(
name="supervisor_agent",
model=LiteLlm(model=llm_model),
description="Coordinates and monitors tasks across retrieval_agent, planner_agent, and executor_agent sub-agents.",
instruction=instruction,
sub_agents=[retrieval_agent, loop_agent],
before_model_callback=simple_before_model_modifier,
after_model_callback=simple_after_model_modifier,
generate_content_config=types.GenerateContentConfig(temperature=0.1),
)

When the planner sub-agent inside the loop_agent tries to invoke the executor sub-agent, I receive the following error:

"error": "Function transfer_to_agent is not found in the tools_dict."

It seems like the function or tool mapping between sub-agents within the LoopAgent isn’t being recognized.

Question:

Is there a specific way to enable agent-to-agent communication or tool transfer within a LoopAgent?
Do I need to define or register the transfer_to_agent function explicitly for nested sub-agents?
What’s the recommended method to allow one sub-agent inside a LoopAgent to call another sub-agent seamlessly?

Any insights, examples, or configuration guidance would be greatly appreciated!

Thank you,

[adk-bot]

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

TLDR: The error occurs because sub-agents within a LoopAgent are treated as siblings and cannot directly call each other. Communication should be managed sequentially by the LoopAgent, where the output of one agent is passed as input to the next.

---

Hi @parthiaitech,

Thank you for your detailed question. I can clarify why you're seeing this error and suggest the recommended approach for this workflow.

Why the Error Occurs

In ADK, agent-to-agent communication is hierarchical. An agent is only given the transfer_to_agent tool if it has sub-agents defined in its configuration. [1] This tool allows a parent agent to delegate tasks to its direct children. [1]

The error "Function transfer_to_agent is not found in the tools_dict" occurs because your planner_agent has no sub-agents of its own. The planner_agent and executor_agent are siblings under the LoopAgent, and siblings cannot directly invoke each other using transfer_to_agent.

How LoopAgent Works

The LoopAgent is a workflow agent designed to execute its sub-agents sequentially in a loop. [2] It passes the output of one agent to the input of the next agent in the sequence. Communication happens passively through the shared context that is passed through each iteration, not through direct invocation. [2]

Recommended Solution: Sequential Execution

To fix this, you should adapt your workflow to the sequential nature of the LoopAgent. The planner_agent should output its plan, and the LoopAgent will then automatically run the executor_agent with that plan as input.

You can modify the prompt for your planner_agent to instruct it to "output a plan for the executor" rather than trying to call it. The executor's prompt can then reference that plan from the shared state.

Alternative Solution: Nested Hierarchy

If your workflow requires the planner to have direct control over invoking the executor, you should change your agent hierarchy:

1. Make executor_agent a sub-agent of planner_agent.
2. Configure the LoopAgent to only have planner_agent in its sequence.

Here’s how that structure would look:

# Executor is now a sub-agent of the Planner
planner_agent = LlmAgent(
    name="planner_agent",
    # ... other params
    sub_agents=[executor_agent]
)

# The LoopAgent now only iterates over the planner
loop_agent = LoopAgent(
    name="loop_agent",
    sub_agents=[planner_agent],
    max_iterations=20
)

# Supervisor remains the same
SupervisorAgent = LlmAgent(
    # ... other params
    sub_agents=[retrieval_agent, loop_agent],
)

With this setup, planner_agent will have the transfer_to_agent tool and will be able to call executor_agent directly. The loop will then repeatedly execute the planner, which can decide if and when to call the executor.

I hope this helps you build your multi-agent system!

---

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