How to chain together multiple tool calls from different remote MCP servers?

[soccernee]

I am trying to build a workflow with ADK that makes multiple MCP tool calls using different remote MCP servers. When using the standard Agent (or LlmAgent), I noticed that only one MCP tool is invoked per execution. That doesn't meet my need to call multiple tools.

I then used a SequentialAgent with multiple sub-agents. However, I am still facing the same problem: calling an MCP tool seems to end the execution. It seems like the sub-agent can either call an MCP tool or pass its output along to the next sub-agent. See this ADK-produced chart to illustrate my dilemma:

In the chart, the geocoding_agent called get_coordinates and ended execution. The path through the execution tree is done. It should have instead passed along the output from get_coordinates to the weather agent.

I'm looking for each sub-agent to (1) call a MCP tool; (2) create some output that is (3) then passed to the next sub-agent. Here is my python code.

# Build a sequential AI agent using Google's Agent Development Kit (ADK)
# This agent chains multiple MCP tool calls together using sub-agents
from google.adk.agents import Agent, SequentialAgent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPServerParams
from typing import Any, Dict

SIMVASIA_TOKEN = "" # redacted

# Sub-agent 1: Geocoding - converts location to coordinates
geocoding_agent = Agent(
    model="gemini-2.5-flash-lite",
    name="geocoding_agent",
    description="Converts location names to latitude and longitude coordinates",
    instruction="""You are a geocoding specialist. Your job is to:
1. Take the location name (city, address, or place) in the prompt
2. Use the geocoding tool to convert it to latitude and longitude coordinates
3. Return ONLY the coordinates and location name in the format: "lat: X.XXX, lon: Y.YYY (location: ZZZZ)"""",
    tools=[
        McpToolset(
            connection_params=StreamableHTTPServerParams(
                url="https://www.simvasia.com/sandbox/simvasia/geocoding_mcp/",
                headers={
                    "X-Sandbox-Token": f"{SIMVASIA_TOKEN}",
                    "Accept": "application/json, text/event-stream"
                },
            ),
        ),
    ],
    output_key="coordinates",  # Stores coordinates in state['coordinates']
)

# Sub-agent 2: Weather - gets weather for coordinates
weather_agent = Agent(
    model="gemini-2.5-flash-lite",
    name="weather_agent",
    description="Fetches current weather data for given coordinates",
    instruction="""You are a weather specialist. Your job is to:
1. Take these latitude and longitude coordinates: {coordinates}
2. Use the weather tool to get current weather conditions
3. Return a concise weather summary including temperature and conditions
4. Format it as a single sentence suitable for a text message""",
    tools=[
        McpToolset(
            connection_params=StreamableHTTPServerParams(
                url="https://www.simvasia.com/sandbox/simvasia/open_meteo_weather_mcp/",
                headers={
                    "X-Sandbox-Token": f"{SIMVASIA_TOKEN}",
                    "Accept": "application/json, text/event-stream"
                },
            ),
        ),
    ],
    output_key="weather",  # Stores weather in state['weather']
)

# Sub-agent 3: SMS - sends text message
sms_agent = Agent(
    model="gemini-2.5-flash-lite",
    name="sms_agent",
    description="Sends SMS text messages",
    instruction="""You are an SMS specialist. Your job is to:
1. Take a message about the weather: {weather}
2. Use the SMS tool to send the message from the provided phone number, to the other provided phone number
3. Return confirmation that the message was sent successfully""",
    tools=[
        McpToolset(
            connection_params=StreamableHTTPServerParams(
                url="https://www.simvasia.com/sandbox/simvasia/twilio_mcp/message-success/",
                headers={
                    "X-Sandbox-Token": f"{SIMVASIA_TOKEN}",
                    "Accept": "application/json, text/event-stream"
                },
            ),
        ),
    ],
    output_key="text_result", # Stores output in state['text_result']
)

# Root agent: Coordinates the sequential workflow
weather_pipeline_coordinator = SequentialAgent(
    name="WeatherSMSCoordinator",
    sub_agents=[geocoding_agent, weather_agent, sms_agent],
    description="Provides weather over SMS by executing a sequence of fetching coordinates, looking up the weather, and sending the weather over SMS to a phone number.",
)

root_agent = weather_pipeline_coordinator

[adk-bot]

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

TLDR: The problem is that your sub-agent's execution turn ends immediately after the MCP tool call. To fix this, you need to refine each sub-agent's instruction to be more explicit, telling it to first call the tool and then process the tool's output to generate a final text response. This final response is what output_key will capture and pass to the next agent.

---

Hello! I can help with this. Your understanding of using a SequentialAgent to chain agents is correct. The issue you're facing is a subtle but common one when working with tool-using agents.

How SequentialAgent and output_key Work

A SequentialAgent executes a series of sub-agents in a defined order. The primary mechanism for passing information between these agents is the session state. As you've done, the standard pattern is to have an earlier agent save its result to the state using the output_key parameter, and a later agent can then access that value from its context (e.g., {coordinates}). [1, 2]

The Problem: The Agent's Turn Ends Too Soon

The output_key captures the content of the final ModelResponseEvent (the agent's text output) for a given turn. In your current setup, what's likely happening is:

1. The geocoding_agent's LLM correctly decides to call the get_coordinates tool from your McpToolset.
2. The tool executes successfully and returns the coordinates. A ToolResponseEvent is logged.
3. The sub-agent's turn concludes. It does not re-invoke the LLM to process the tool's output.
4. Since no final text response (ModelResponseEvent) is generated by the agent, the output_key has nothing to save to the state['coordinates']. The weather_agent then fails because {coordinates} is empty.

The Solution: Refine Your Instructions

To solve this, you need to make your instructions more explicit. You must guide the LLM to perform two steps: first, call the tool, and second, use the tool's output to formulate a final text response. It is this final response that will be captured.

Here is a revised version of your geocoding_agent with a more robust instruction:

# Sub-agent 1: Geocoding - converts location to coordinates
geocoding_agent = Agent(
    model="gemini-2.5-flash-lite",
    name="geocoding_agent",
    description="Converts location names to latitude and longitude coordinates",
    instruction="""You are a geocoding specialist. Your job is to:
1. Identify the location name (e.g., city, address) from the prompt.
2. Use the `get_coordinates` tool to find its latitude and longitude.
3. After the tool returns the result, you MUST formulate a final text response.
4. This final response must ONLY contain the coordinates and location name in the format: "lat: X.XXX, lon: Y.YYY (location: ZZZZ)".""",
    tools=[
        McpToolset(
            connection_params=StreamableHTTPServerParams(
                url="https://www.simvasia.com/sandbox/simvasia/geocoding_mcp/",
                headers={
                    "X-Sandbox-Token": f"{SIMVASIA_TOKEN}",
                    "Accept": "application/json, text/event-stream"
                },
            ),
        ),
    ],
    output_key="coordinates",  # Stores the agent's final text output in state['coordinates']
)

By explicitly stating "After the tool returns the result, you MUST formulate a final text response," you guide the agent to re-invoke the LLM, process the tool's output, and generate the final string. This string will then be correctly saved to state['coordinates'] for the weather_agent to use.

You should apply this same instructional pattern to your weather_agent and sms_agent as well, ensuring they are explicitly told to process their respective tool outputs and create a final summary or confirmation message.

This should resolve the issue and allow your SequentialAgent to correctly chain the MCP tool calls.

---

[1] ADK Documentation: Multi-Agent Systems
[2] ADK Documentation: Sequential Agents

[soccernee]

Thank you, this generally works. I'm finding that the new prompt sometimes works (and sometimes doesn't). It seems like more experimentation is needed with the prompt to successfully make it through the workflow consistently.

That said, I find it a bit odd that the workflow stops early even after I defined a SequentialAgent, which in theory is supposed to execute all sub-agents in sequence. If there are other agents or parameters that can be used to ensure execution of all sub-agents, please let me know.