transfer_to_agent to parent/caller agent not possible for the sub agents

[Satheesh-Balachandran]

We are working to create a Multi-Agent system. And I realised that transfer_to_agent tool is given only to agents that have sub-agents.

In a scenario where,

• Parent agent reasons and delegates the task to a sub agent A using transfer_to_agent
• Sub agent A realises it cannot fulfil the request
• The request needs to be transferred back to the parent agent to again work on the plan and maybe delegate to some other agent

Currently, since sub agents can't transfer to parent the user query becomes unanswered. What's the suggestion or architecture to fix this use case?

[adk-bot]

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

TLDR: You can achieve this by using tool_context.actions.escalate = True within a custom tool for your sub-agent. This will transfer control back to the parent agent.

---

Hello! As an AI assistant for the ADK repository, I can provide some guidance on your multi-agent architecture question.

You are correct that by default, sub-agents do not have the transfer_to_agent tool. However, ADK provides a mechanism for a sub-agent to escalate a task back to its parent agent when it's unable to complete it.

The recommended way to handle this is to create a custom tool for your sub-agent. Inside this tool's implementation, if you determine that the sub-agent cannot fulfill the request, you can set tool_context.actions.escalate = True. This will signal the ADK framework to stop the execution on the current sub-agent and pass the control back to its parent agent. The parent can then re-evaluate the plan and delegate the task to another agent if needed.

Here is a conceptual example of what this might look like in a custom tool for your sub-agent:

from adk.tools import tool
from adk.tools.tool_context import ToolContext

@tool.implement
def my_sub_agent_tool(input: str, tool_context: ToolContext) -> str:
    if not can_handle(input):
        # Escalate to the parent agent
        tool_context.actions.escalate = True
        return "Cannot handle this request, escalating to parent."
    
    # ... rest of the tool logic
    return "Task completed successfully."

This approach allows you to build a robust hierarchical agent system where tasks can be delegated and escalated as needed. You can find more details about this in the ADK documentation on custom tools. [1]

---

[1] https://google.github.io/adk-docs/tools-custom/

[Satheesh-Balachandran]

I created this function:

def out_of_scope_handler(tool_context: ToolContext):
    tool_context.actions.escalate = True

And added it part of my tools using tools=tools + [FunctionTool(out_of_scope_handler)]. But the transfer seem to not work as the event is not getting added

[Andrej-Marsic]

@Satheesh-Balachandran Did you resolve this?

I am checking for a similar case. I've noticed that in the current setup the agent then reaches to the user, but I'd prefer if there was a way to prevent that and instead go to the parent agent.

[Satheesh-Balachandran]

I think the behaviour changed in recent days and the tool_context.actions.escalate = True is working now to exit out of loop agent. Not really tested it the way I tried earlier from the sub agent to parent agent on out of scope. But I guess it's working now.

[nikita-ermolaev-coral]

Any updates here?

@adk-bot

[adk-bot]

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

TLDR: Instead of having the sub-agent use transfer_to_agent to return control to the parent, you should use a mechanism where the sub-agent completes its turn (either with a result or a failure) and control automatically returns to the parent. The parent can then inspect the outcome and decide the next step, such as delegating to a different agent. ADK provides several patterns for this, with the new collaboration modes in v2.0+ being the most direct solution.

---

Hello! That's an excellent question about multi-agent architecture in ADK. You are correct that transfer_to_agent is designed for delegating tasks downwards or sideways in a hierarchy, not for returning control upwards to the parent. The parent agent that initiates a transfer is expected to regain control after the sub-agent completes its work.

Here are a few architectural patterns supported by ADK to solve your use case:

1. Use task or single_turn Collaboration Modes (Recommended)

With the release of ADK Python v2.0.0 Alpha, new collaboration modes were introduced that are designed for this exact scenario. [1] When you define a sub-agent relationship, you can specify a mode:

• task mode: The sub-agent works to complete the task and, upon completion, control automatically returns to the parent agent.
• single_turn mode: The sub-agent runs for one turn and returns the result, with control reverting to the parent.

In your case, you would configure the sub-agent A with task mode. When A realizes it cannot fulfill the request, it would simply finish its execution (e.g., by returning a status indicating failure). The parent agent would then automatically resume control, see the failure result from A, and can then proceed with its plan to delegate to another agent.

2. Use the "Agent-as-a-Tool" Pattern

Another approach is to not use transfer_to_agent at all, but instead treat your sub-agents as tools. [2] In this pattern:

• The parent agent's instruction processing logic remains active.
• It invokes the sub-agent A as if it were a function call (a tool).
• The parent agent receives the output from sub-agent A as a tool result.

If sub-agent A fails, it returns an error or a specific message. The parent agent receives this message, and since it never fully relinquished control, it can immediately decide to call a different sub-agent tool.

3. Use the escalate Action in a Custom Tool

A tool within your sub-agent can programmatically signal that it cannot handle a request and that control should be passed back to the parent agent. This is done using tool_context.actions.escalate. [3, 4]

If a tool in sub-agent A determines it's unable to proceed, it can set:

tool_context.actions.escalate = True

This will stop the sub-agent's execution and pass control back up to the parent, which can then handle the escalated situation.

For most new multi-agent systems, using the task collaboration mode is the cleanest and most idiomatic solution for the problem you've described.

[1] https://google.github.io/adk-docs/workflows/collaboration/
[2] https://google.github.io/adk-docs/tools-custom/
[3] https://google.github.io/adk-docs/tools-custom/function-tools/
[4] https://google.github.io/adk-docs/events/

[jasveer-os]

Doesn't escalate work only for LoopAgent?