Human in the loop within custom agent and SequentialAgent workflow does not pause execution

[yanbin-pan]

Description

When a Custom agent overrides the _run_async_impl method, it does not correctly pause its execution when a sub-agent enters a PAUSED state due to tool_context.request_confirmation(). The custom agent is built as described in: https://google.github.io/adk-docs/agents/custom-agents/#design-pattern-example-storyflowagent

The parent agent's async for event in sub_agent.run_async(ctx): loop completes as soon as the first confirmation is requested. The parent agent's logic then immediately continues to the next step, instead of waiting for the user to provide the confirmation and for the sub-agent to resume and complete its task.

In the provided example, DeepAnalyticsAgent (parent custom agent) invokes task_brief_agent (sub-agent). This sub-agent correctly requests user confirmation and pauses. However, DeepAnalyticsAgent does not wait; it proceeds instantly to invoke task_supervisor_agent, breaking the intended sequential workflow.

My Custom Agent has 2 sub-agents

• Sub A and Sub B.
• Sub A uses a Advanced Tool confirmation as described in: https://google.github.io/adk-docs/tools/confirmation/#advanced-confirmation
• Once Sub A makes the user request then Sub B starts immediately before the user replies in the payload of Sub A.
• Parent agent does not resume and kicks off Sub B once the payload is submitted.

To Reproduce

1. Define a tool (_confirm_research_brief) that uses tool_context.request_confirmation().

2. Assign this tool to a sub-agent (task_brief_agent).

3. Define a custom parent agent (DeepAnalyticsAgent) that overrides _run_async_impl.

4. Inside _run_async_impl, sequentially invoke task_brief_agent and then another agent (task_supervisor_agent) using run_async.

5. Execute the DeepAnalyticsAgent.

Observe that task_supervisor_agent begins execution as soon as the confirmation UI for task_brief_agent is displayed, without waiting for user input.

def _confirm_research_brief(research_brief: str, tool_context: ToolContext) -> str:
    """Function tool to request user confirmation of the research brief."""
    tool_confirmation = tool_context.tool_confirmation

    if not tool_confirmation:
        tool_context.request_confirmation(
            hint=(
                'Please review the research brief and confirm if it is satisfactory.'
            ),
            payload={
                'approved': 'no',
                'edit_brief': ''
            },
        )
        return {'status': 'User Approval Requested'}

    approved = tool_confirmation.payload.get('approved', 'no').lower()

    if approved == 'yes':
        # SUCCESS: Set the final state with the original brief.
        tool_context.state["final_task_brief"] = research_brief
        return {"status": "The user approved the brief."}

    elif approved == 'edit':
        edited_brief = tool_confirmation.payload.get('edit_brief')
        if edited_brief:
            # SUCCESS: Set the final state with the EDITED brief.
            tool_context.state["final_task_brief"] = edited_brief
            return {"status": "The user edited and approved the brief."}
        else:
            # Handle case where user chose 'edit' but provided no text.
            tool_context.state["final_task_brief"] = None
            return {"status": "User chose edit but provided no changes. Rejection assumed."}

    else: # 'no' or any other case
        # REJECTION: Explicitly set the state to None to signal failure.
        tool_context.state["final_task_brief"] = None
        return {"status": "The user rejected the brief."}

task_brief_agent = LlmAgent(
    model=LLM_MODEL,
    name="task_brief_agent",
    description="Takes user question and generates a research brief to guide the process of addressing it.",
    instruction=ENV_PROMPT.get_template("task_brief.j2").render(),
    tools=[AgentTool(agent=rag_agent), _confirm_research_brief],
    output_key="task_brief",
)


class DeepAnalyticsAgent(BaseAgent):
    task_brief_agent: LlmAgent
    task_supervisor_agent: TaskSupervisorAgent
    model_config = {"arbitrary_types_allowed": True}

    def __init__(
        self,
        name: str,
        task_brief_agent: LlmAgent,
        task_supervisor_agent: TaskSupervisorAgent,
    ):
        sub_agents_list = [
            task_brief_agent,
            task_supervisor_agent,
        ]

        super().__init__(
            name=name,
            task_brief_agent=task_brief_agent,
            task_supervisor_agent=task_supervisor_agent,
            sub_agents=sub_agents_list, 
        )
    
    @override
    async def _run_async_impl(
        self, ctx: InvocationContext
    ) -> AsyncGenerator[Event, None]:
        if not self.sub_agents:
            return

        async for event in self.task_brief_agent.run_async(ctx):
            logger.info(f"[{self.name}] Task Sequence Event: {event.model_dump_json(indent=2, exclude_none=True)}")
            yield event
        
        task_brief = ctx.session.state["task_brief"]
        print(task_brief)

        async for event in self.task_supervisor_agent.run_async(ctx):
            logger.info(f"[{self.name}] Task Sequence Event: {event.model_dump_json(indent=2, exclude_none=True)}")
            yield event

root_agent = DeepAnalyticsAgent(
    name="DeepAnalyticsAgent",
    task_brief_agent=task_brief_agent,
    task_supervisor_agent=task_supervisor_agent,
)

Expected behavior
The execution of the parent DeepAnalyticsAgent should pause when task_brief_agent requests user confirmation. The async for loop iterating over self.task_brief_agent.run_async(ctx) should not complete until the sub-agent's lifecycle for the current task is fully finished (i.e., after the user responds and the agent processes that response). The task_supervisor_agent should only begin its execution after this confirmation is received and handled.

Desktop (please complete the following information):

• OS: macOS
• Python version(python - v.12:
• ADK version(pip show google-adk): 1.16.0

Model Information:

• Are you using LiteLLM: No
• Which model is being used: gemini-2.5-flash

[yanbin-pan]

I also experimented with using LongRunningFunctionTool to implement HITL, following the approach described here: https://google.github.io/adk-docs/tools/function-tools/#long-run-tool.
However, I observed the same behavior with sub-agents inside a workflow — even when using a SequentialAgent. Specifically, when a sub-agent wrapped with LongRunningFunctionTool pauses, the SequentialAgent still proceeds to execute the next agent instead of waiting.

The example below reproduces this behavior.

from typing import Any
from google.adk.tools import LongRunningFunctionTool


# 1. Define the long running function
def ask_for_approval(
    purpose: str, amount: float
) -> dict[str, Any]:
    """Ask for approval for the reimbursement."""
    # create a ticket for the approval
    # Send a notification to the approver with the link of the ticket
    return {'status': 'pending', 'approver': 'Sean Zhou', 'purpose' : purpose, 'amount': amount, 'ticket-id': 'approval-ticket-1'}

def reimburse(purpose: str, amount: float) -> str:
    """Reimburse the amount of money to the employee."""
    # send the reimbrusement request to payment vendor
    return {'status': 'ok'}

# 2. Wrap the function with LongRunningFunctionTool
long_running_tool = LongRunningFunctionTool(func=ask_for_approval)

# 3. Use the tool in an Agent
file_processor_agent = LlmAgent(
    # Use a model compatible with function calling
    model=LLM_MODEL,
    name='reimbursement_agent',
    instruction="""
      You are an agent whose job is to handle the reimbursement process for
      the employees. If the amount is less than $100, you will automatically
      approve the reimbursement.

      If the amount is greater than $100, you will
      ask for approval from the manager. If the manager approves, you will
      call reimburse() to reimburse the amount to the employee. If the manager
      rejects, you will inform the employee of the rejection.
    """,
    tools=[reimburse, long_running_tool],
    output_key='human_decision'
)

# Agent that proceeds based on human decision
process_decision = LlmAgent(
    name="ProcessDecision",
    model=LLM_MODEL,
    instruction="Check {human_decision}. If 'approved', proceed return 'great it is approved!', else return 'not approved, stopping here.'",
)

root_agent = SequentialAgent(
    name="HumanApprovalWorkflow",
    sub_agents=[file_processor_agent, process_decision]
)

[DeanChensj]

Hi @yanbin-pan, in order to be able to pause the execution with long running tools, you should turn on the resumability_config in the App.

See: https://github.com/google/adk-python/blob/main/contributing/samples/human_tool_confirmation/agent.py#L98-L99 as an example. And https://google.github.io/adk-docs/runtime/resume/#add-resumable-configuration is the document

[jpantsjoha]

Hi @yanbin-pan and @DeanChensj,

I've submitted PR #3224 that provides an alternative solution to this parent agent pause issue that doesn't require resumability_config or manual FunctionResponse injection:

🔗 PR #3224: #3224

The Problem (as described here)

When a sub-agent uses LongRunningFunctionTool, the parent SequentialAgent doesn't wait for the approval and proceeds to the next agent immediately.

Alternative Approach: Backend Blocking Poll Pattern

Instead of using LongRunningFunctionTool with resumability_config, you can use a backend blocking poll pattern where the approval tool polls internally and returns the final decision:

import asyncio
import httpx

async def request_approval_blocking_async(proposal: str) -> dict:
    """Request approval via external API, polling until decision is made."""
    
    # Create approval ticket
    async with httpx.AsyncClient() as client:
        response = await client.post(f"{APPROVAL_API_URL}/approvals", 
                                     json={"proposal": proposal})
        ticket_id = response.json()["ticket_id"]
    
    # Poll for decision (blocks until approved/rejected or timeout)
    poll_interval = 30  # seconds
    timeout = 600  # 10 minutes
    elapsed = 0
    
    while elapsed < timeout:
        await asyncio.sleep(poll_interval)
        
        async with httpx.AsyncClient() as client:
            response = await client.get(f"{APPROVAL_API_URL}/approvals/{ticket_id}/status")
            status = response.json()["status"]
            
            if status in ["approved", "rejected"]:
                return {"decision": status, "ticket_id": ticket_id}
        
        elapsed += poll_interval
    
    return {"decision": "timeout", "ticket_id": ticket_id}

# Use in agent (no LongRunningFunctionTool wrapper needed)
reimbursement_agent = LlmAgent(
    model=LLM_MODEL,
    name='reimbursement_agent',
    instruction="""Handle reimbursement. For amounts >, call 
    request_approval_blocking_async() and wait for decision.""",
    tools=[reimburse, request_approval_blocking_async]  # Direct tool, not wrapped
)

Key Benefits

✅ Agent naturally waits: The tool blocks until decision is made, so parent agent doesn't proceed early
✅ No resumability_config needed: Standard agent execution flow
✅ No manual FunctionResponse: Tool returns final decision directly
✅ Simpler code: No need to manage pending state and continuation
✅ 93% fewer LLM API calls: 1 inference vs 15+ with agent-level polling (production validated)

When to Use This Pattern

Use Backend Blocking Poll when:

• External system doesn't support webhooks (poll-only systems like Jira, ServiceNow)
• Approval typically completes in <10 minutes
• Simple approval workflow (single decision)

Use LongRunningFunctionTool + resumability_config when:

• External system supports webhooks/callbacks
• Need to show progress updates during waiting
• Multi-step approval workflows
• Very long-duration approvals (>10 minutes)

Full Working Example

PR #3224 includes:

• Sync and async implementations
• Mock approval API with HTML dashboard
• 20 tests (100% pass rate)
• Comprehensive README with decision matrix

The pattern has been validated in production for multi-agent RFQ approval workflows with 10-minute average approval durations.

Hope this provides a useful alternative! Let me know if you have questions about the approach.