Multi-turn conversations in Sequential (sub) Agents

[riturajtiwari]

I'm running into an issue where I have a sequence of two steps.

• Step 1: SetupAgent: Asks user for a Google Drive folder, analyzes contents, asks user some clarifying questions, then prepares information to be passed to step 2:
• Step 2: ContextAgent: Uses information from step 1 to do further analysis and have a multi-turn interaction with the user

I'm using the setup like this:

• I create a SequentialAgent with these two agents as steps
• I run the pipeline
• I type "Hi"
• Actual Behavior: Both agents show their greeting prompts one after the other
• Expected behavior: The first agent to initiate and complete the dialog before moving to the second agent.

I'm clearly not doing something right. Any pointers will help.

[adk-bot]

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

TLDR: The SequentialAgent is designed to run through all its sub-agents in order for each single turn of a conversation. It does not wait for one sub-agent to complete a multi-turn dialogue before starting the next.

---

Hello! Thanks for your question. The behavior you're observing is the intended functionality of the SequentialAgent. Let me explain why and suggest an alternative pattern for your use case.

Understanding SequentialAgent

The SequentialAgent acts as a pipeline, executing each of its sub-agents in a fixed order within a single conversational turn. When your SequentialAgent receives the input "Hi", it performs the following steps in the same turn:

1. It runs the first sub-agent, SetupAgent. This agent generates its greeting.
2. It then immediately runs the second sub-agent, ContextAgent. This agent also generates its greeting.

This is why you see both greetings one after the other. The primary purpose of SequentialAgent is to chain tasks where the output of one step becomes the input for the next, all within a single invocation, often using shared session state to pass data [1].

Proposed Solution: The Controller Pattern

For your goal, where one agent must complete a full, multi-turn conversation before another begins, you need a different orchestration approach. I recommend using a "Controller" agent that decides which sub-agent should be active at any given time.

You can implement this using a CustomAgent for explicit control [3].

Here is a conceptual example of how a CustomAgent acting as a controller would work:

from google.adk.agents import CustomAgent, InvocationContext, Event

class ControllerAgent(CustomAgent):
    async def _run_async_impl(self, ctx: InvocationContext) -> AsyncGenerator[Event, None]:
        # Check a flag in the session state to see if setup is complete.
        setup_is_complete = ctx.session.state.get('setup_complete', False)

        if not setup_is_complete:
            # If setup is not complete, delegate to the SetupAgent.
            # The SetupAgent would be responsible for setting state['setup_complete'] = True when done.
            active_agent = self.find_agent('SetupAgent')
        else:
            # Once setup is complete, delegate to the ContextAgent.
            active_agent = self.find_agent('ContextAgent')

        # Run the currently active agent.
        async for event in active_agent.run_async(ctx):
            yield event

In this pattern:

1. The ControllerAgent is the main agent you run.
2. Your SetupAgent would need to be modified to set a flag in the session state (e.g., ctx.session.state['setup_complete'] = True) once its interaction is finished.
3. The ControllerAgent checks for this flag on each turn to decide whether to run the SetupAgent or the ContextAgent.

This approach gives you the control needed to manage distinct conversational phases. You could also achieve a similar result using an LlmAgent with instructions that guide it to delegate tasks to the appropriate sub-agent based on the conversation's progress, a pattern known as LLM-Driven Delegation [2].

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

---

[1] ADK Docs: Sequential Agents - https://google.github.io/adk-docs/agents/workflow-agents/sequential-agents/
[2] ADK Docs: Multi-Agent Systems - https://google.github.io/adk-docs/agents/multi-agents/
[3] ADK Docs: Custom Agents - https://google.github.io/adk-docs/agents/custom-agents/

[riturajtiwari]

How would I instruct an agent (via system instructions) to put state, like setup complete in the context?

[riturajtiwari]

@adk-bot Also note that I cannot find from google.adk.agents import CustomAgent in the ADK code. Are you sure this code sample is right?

[riturajtiwari]

How would I instruct an agent (via system instructions) to put state, like setup complete in the context?

[adk-bot]

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

TLDR: SequentialAgent executes its sub-agents in order within a single turn. For your SetupAgent to complete its own multi-turn conversation before the next agent begins, you should encapsulate the multi-turn logic within the SetupAgent itself, potentially using a LoopAgent to manage the conversation until it's complete.

---

Hello @riturajtiwari,

Thank you for your question. This is a great question that highlights the difference between single-turn sequences and multi-turn conversations in ADK.

The behavior you're observing is expected. The SequentialAgent is a workflow agent designed to execute a series of sub-agents in a specific order within a single invocation or turn. When you send "Hi", the SequentialAgent runs SetupAgent, which yields its greeting, and then immediately proceeds to run ContextAgent, which yields its greeting.

To achieve your desired behavior, you need to design your SetupAgent to manage the full multi-turn interaction internally and only yield control back to the parent agent once its specific task is complete.

A common and powerful pattern for this in ADK is to use a LoopAgent. You can structure your workflow so that the SetupAgent runs inside a loop, collecting information from the user at each step. The loop terminates only when a specific condition is met (e.g., all required information is gathered).

Here’s a conceptual example based on the "Iterative Refinement Pattern" found in the ADK documentation [1]:

1. Create a LoopAgent: This agent will contain your SetupAgent.
2. Implement SetupAgent: This agent handles one part of the conversation (e.g., asking a question). It will store the information it gathers in the shared session state.
3. Create a "Checker" Agent: This is a small, custom agent inside the LoopAgent that runs after SetupAgent. Its job is to check the state to see if the conversation is finished.
4. Signal Completion: If the "Checker" agent determines the conversation is done, it returns an Event with actions=EventActions(escalate=True). This escalate action signals to the parent LoopAgent that it should stop looping.

Your main pipeline would then look something like this:
SequentialAgent(sub_agents=[setup_loop, context_agent])
where setup_loop is the LoopAgent containing SetupAgent and the checker.

Alternatively, for very complex conditional logic, you could implement a Custom Agent [2] that would act as the orchestrator. This custom agent's _run_async_impl method would contain the logic to repeatedly call SetupAgent until it's done, and then call ContextAgent.

You can find more details on these patterns in the ADK documentation.

[1] Multi-Agent Systems in ADK: https://google.github.io/adk-docs/agents/multi-agents/
[2] Custom Agents: https://google.github.io/adk-docs/agents/custom-agents/
[3] Loop Agents: https://google.github.io/adk-docs/agents/workflow-agents/loop-agents/

---

This response was generated by an automated assistant.