Chaining Tools for Multi-Step Workflows

Hello! Welcome back to our exploration of agent capabilities.

In our last lesson, you successfully implemented the fundamental function calling loop. You learned how to define tools, have an LLM decide to use one, execute it in your application, and feed the result back to the model for a final, synthesized answer. This covered single actions and parallel actions.

Today, we're taking the next logical step. What happens when a query is too complex to be answered by a single tool call? For instance, a query like "What's the current weather in the city where the Eiffel Tower is located?" requires a sequence of actions: first, identify the city (Paris), and then get the weather for that city.

Our learning outcome is to handle multi-step tool chains where one tool's output feeds into another. This is the essence of an agent's ability to reason and form a plan, moving beyond simple reflexes to tackle more sophisticated problems.

The Agentic Loop: From Single Action to a Chain

The single tool call you implemented last time is one iteration of a fundamental pattern in AI agents called the agentic loop. The core idea is a cycle of reasoning and interacting with an environment.

In our last lesson, this loop ran exactly once:

1. Plan: The LLM decided to call a tool.
2. Act: Your code executed the tool.
3. Observe: Your code fed the result back to the LLM.
4. Final Answer: The LLM, having all the info, stopped the loop and gave an answer.

A multi-step chain is simply this same loop running multiple times. After observing the result of the first tool, the LLM might decide its next plan is to call another tool, using the information it just received. This continues until it has enough information to provide a final answer.

Managing the state (the history of messages, tool calls, and tool results) through these cycles is critical. While you can build this logic from scratch, specialized frameworks exist to make it much more manageable. We'll be looking at LangGraph, an extension of the LangChain library, which is purpose-built for creating these stateful, graph-based agent workflows.

A Concrete Example: The Two-Step Weather Query

Let's build a practical example to make this concrete. We want an agent that can answer: "What's the current weather like in Karachi?"

To a human, this is one step. But for a computer with specific tools, it's a two-step process:

1. Tool 1: Geocoding. Convert the string "Karachi" into geographic coordinates (latitude and longitude).
2. Tool 2: Weather API. Use the coordinates from Step 1 to call a weather service and get the current conditions.

The output of the first tool is the direct input for the second. Let's see how this is implemented.

The following article provides a superb, code-centric walkthrough. As a software engineer, you'll appreciate its Pydantic-based, structured approach. First, let's examine how the tools are defined to facilitate this chain.

Now that we have the tools, we need an orchestrator to manage the flow between them. This is where LangGraph comes in. It builds a state machine where nodes represent actions (like calling the LLM or executing a tool) and edges represent the transitions between them.

This next section of the article explains how to build the agent and its workflow.

To summarize the flow for the query "What's the weather in Karachi?":

1. The user's query enters the "agent" node. The LLM sees it needs coordinates and decides to call get_coordinates_from_city.
2. The graph's logic routes to the "tools" node, which executes the function. The output is a JSON object with Karachi's latitude and longitude.
3. The edge from "tools" back to "agent" sends this coordinate data back into the workflow.
4. The "agent" node is invoked again. The LLM now has the original query and the coordinates. It sees the next logical step is to get the weather. It calls get_current_weather with the coordinates it just received.
5. The process repeats: the "tools" node executes the weather tool and returns the current weather data.
6. This result is sent back to the "agent" node. The LLM now has all the necessary information. Instead of calling another tool, it generates the final, human-readable answer.

The best way to be sure this is happening is to test it. The article provides an excellent end-to-end test that traces the agent's execution path, proving the chain works as intended.

Advanced Chains: Dynamic and Iterative Workflows

The simple A -> B chain is just the beginning. The agentic loop, especially when managed by a framework like LangGraph, can create far more complex and dynamic workflows.

The video below provides a great conceptual overview of the fundamental agent loop and then explores more advanced patterns.

This same looping mechanism enables more powerful behaviors:

• Orchestrator/Worker: An LLM planner acts as a project manager. It receives a complex task (e.g., "write a report on scaling laws"), breaks it down into sub-tasks (introduction, fundamentals, etc.), and dynamically spawns "worker" agents to handle each part.
• Evaluator/Optimizer: An agent enters a loop where one part generates a response (e.g., writes a piece of code or a joke), and another part evaluates it against certain criteria. If it fails the evaluation, it's sent back for revision. The loop continues until the output is satisfactory.

Let's watch a brief overview of these patterns. You don't need to absorb all the code; focus on understanding the workflow possibilities.

These advanced patterns demonstrate that by chaining tools within an agentic loop, you can move from simple command execution to sophisticated, goal-oriented problem-solving.

Conclusion

In this lesson, we elevated our agent's capabilities from single actions to multi-step reasoning. You learned how to create tool chains where the output of one step becomes the critical input for the next.

Key Takeaways:

• Multi-step tasks are handled by running the agentic loop (Plan -> Act -> Observe) multiple times.
• The agent's state, which includes the full history of actions and their results, is maintained across each step of the chain.
• Frameworks like LangGraph are designed to manage this stateful, cyclical logic by defining workflows as graphs of nodes and edges.
• The key to chaining is the loop: after a tool executes, its output is returned to the LLM, which then decides the next action based on this new information.
• This pattern enables not only simple sequential chains (A -> B) but also dynamic and iterative workflows like orchestrator/worker and evaluator loops.

You can now build agents that can decompose a problem, execute a plan, and use intermediate results to inform subsequent actions.

In our next lesson, we'll focus on making these chains more robust. We will cover error handling and validation for tool call results, addressing what to do when tools fail, return unexpected data, or encounter other real-world issues.