Inquiry Regarding Human-in-the-Loop (HITL) Support for AgentTool and A2A Agents

[leoromero]

Hi everyone,

First off, thanks for all the great work on this framework.

I'm designing a multi-agent system and have run into an issue when implementing Human-in-the-Loop (HITL) functionality using a FunctionTool with confirmation enabled.

It appears the confirmation/HITL prompt is not being triggered in two scenarios:

AgentTool: When the FunctionTool is called from within an AgentTool.

A2A Agents: When the tool is part of an A2A agent. My assumption is this is because the resumability_config isn't passed through the to_a2a() method.

Could you please confirm if this is the expected behavior or if I might have misconfigured something?

The ability to use HITL within scalable A2A agents would be incredibly powerful for our use case, as it would prevent us from having to tightly couple agents for tasks requiring human oversight.

Thanks in advance for any insights!

Best, Leo

[adk-bot]

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

TLDR: Your observations are correct. The standard, synchronous require_confirmation on a FunctionTool is not designed to work within AgentTool or across A2A boundaries. The recommended approach for implementing Human-in-the-Loop in these scenarios is to use a LongRunningFunctionTool to manage the asynchronous approval process.

---

Hi Leo,

Thanks for the great question. You've run into a key architectural consideration when building multi-agent systems with human oversight.

Your analysis is spot on. The behavior you're seeing is expected. The require_confirmation parameter on a FunctionTool is intended for simpler, single-agent workflows where the agent is tightly coupled with a user interface that can present a blocking confirmation prompt. [1]

In distributed systems, such as those using A2A (agent-to-agent) communication or nested agents via AgentTool, this synchronous blocking model is not suitable. The remote or nested agent does not have direct access to the user interface of the root agent to ask for confirmation.

Recommended Solution: Asynchronous HITL with LongRunningFunctionTool

The framework provides a robust pattern for this exact use case using a LongRunningFunctionTool. This approach handles the asynchronous nature of waiting for human input without blocking the entire agent system.

We have a specific sample, a2a_human_in_loop, that demonstrates this pattern. You can find it here: [2].

The general workflow is as follows:

1. A root agent delegates a task to a remote A2A agent.
2. The A2A agent determines that it needs human approval to proceed.
3. Instead of using a simple confirmation, it calls a LongRunningFunctionTool. This pauses the A2A agent's execution and signals back to the root agent that human input is required.
4. The root agent, which has access to the user, gets the necessary approval.
5. The root agent then resumes the paused LongRunningFunctionTool on the A2A agent with the human's decision.

This architecture prevents you from having to tightly couple the agents, just as you hoped, and is scalable for complex multi-agent setups.

Regarding your point on resumability_config, you are correct that it is not passed through the to_a2a() method. Resumability is an application-level configuration on the App object, and to_a2a is concerned with serving a specific agent as a service. [3]

I hope this helps clarify the intended design and provides a clear path forward!

[1] https://google.github.io/adk-docs/tools/function-tools/
[2] https://github.com/google/adk-python/blob/main/contributing/samples/a2a_human_in_loop/README.md
[3] https://github.com/google/adk-python/blob/main/src/google/adk/apps/app.py

[leoromero]

oh nice example!
I think I was using a LoopAgent in my test within A2A and that is why it didn't trigger the confirmation,
anyway, is there a way of using to_a2a() with the resumability config so I can use HITL within workflows agents?