How do I run a longrunning function tool within a Sequential/Loop Agent?

[Arvind-Raman-1]

I’m building a SequentialAgent with two sub-agents (A → B). One of A’s actions needs manual approval before it runs, so I wrapped it with a long-running function tool that returns a pending state until I approve/deny it.

The issue: when Sub-agent A hits the approval step and returns pending, the SequentialAgent doesn’t pause. It just keeps going and executes Sub-agent B anyway. I only want B to run after A finishes and yields its approved event.

I’ve tried catching the pending status inside run_async, but every approach I’ve tried either breaks the sequence or exits the entire flow.

Has anyone found a clean way to force the SequentialAgent to actually wait for a sub-agent’s long-running tool to resolve before continuing?

[Arvind-Raman-1]

@adk-bot

[adk-bot]

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

TLDR: The SequentialAgent is designed to execute sub-agents in a fixed order and does not have a built-in mechanism to pause and wait for a LongRunningFunctionTool to complete. The recommended ADK approach is to let the agent's run finish with a "pending" status. The client application that invoked the agent is then responsible for waiting for the manual approval and resuming the workflow with the result.

---

Hello! That's a great question about handling asynchronous operations within a SequentialAgent. Here’s an explanation of how this works in ADK and a suggested approach.

When a LongRunningFunctionTool is used for an operation like manual approval, it is expected to return a "pending" status. This signals that the task has started but is not yet complete. When this happens, the agent's current run is paused or ended. The SequentialAgent is built to run its sub-agents one after another in a strict sequence. When sub-agent A finishes its run (by returning the "pending" status from the tool), the SequentialAgent considers its task complete and proceeds to sub-agent B.

The intended architecture for this scenario involves your client application managing the "pending" state. Here is a breakdown of the recommended workflow:

1. Initiate and Pause: Your SequentialAgent runs, and sub-agent A calls the long-running tool, which returns a pending status. The overall agent run completes, signaling to your client application that it needs to wait for an external event (the approval).

2. Client-Side Wait: The client application now waits for the approval to be given. This happens outside of the ADK agent's execution flow.

3. Resume with Result: Once the approval is granted, the client application sends a new request to the agent, providing the result of the long-running operation. The agent can then resume its work. The "Resuming a workflow" documentation might be helpful to see how to restart an agent from a saved state.

A great reference for this pattern is the A2A Human-in-the-Loop Sample Agent [1]. In this example, a root agent delegates an approval task. It receives a "pending" response and the workflow pauses. A human manager then interacts with the system to provide the approval, which then allows the process to continue.

While this is different from having the SequentialAgent itself pause, it's the standard way to handle long-running and human-in-the-loop tasks within the ADK framework.

I hope this helps clarify the designed behavior and provides a path forward!

[1] A2A Human-in-the-Loop Sample Agent - https://github.com/google/adk-python/blob/main/contributing/samples/a2a_human_in_loop/README.md

[Arvind-Raman-1]

Client-Side Wait: The client application now waits for the approval to be given. This happens outside of the ADK agent's execution flow.

how does this look like?

[DeanChensj]

Hi @Arvind-Raman-1 , it is likely that you are missing the resumablity config setting in the App level, see: https://google.github.io/adk-docs/runtime/resume/#add-resumable-configuration