Orchestrating Agent Workflows

Welcome! Today, we’ll see how to orchestrate multiple agents in a loop — a key skill for building real-world AI systems. Imagine managing a team: one member tracks your tasks, another helps you learn. How do you coordinate them to handle requests one after another? That’s our focus.

By the end, you’ll know how to set up a manager agent that coordinates other agents, processes user requests in sequence, and delegates tasks efficiently. This is essential for building multi-agent systems, from productivity tools to intelligent assistants.

Let’s clarify what a manager agent is and why it matters. In a multi-agent system, each agent is specialized:

• A Todo Agent manages your tasks.
• A Learning (RAG) Agent helps with learning materials.

To handle varied user requests — like “List all my tasks” or “What are my learning plans for React?” — you need a coordinator. The manager agent fills this role, listening to the user, picking the right agent for the job, and delegating. This keeps your system organized and scalable.

Here’s a simple manager agent setup:

from todo_agent import TODO_AGENT
from rag_agent import RAG_AGENT
from agents import Runner, Agent
from rag_builder import build_rag

MANAGER_AGENT = Agent(
    name="Manager Agent",
    instructions=(
        "You are a manager agent that orchestrates multiple agents. "
        "You can delegate tasks to the Todo Agent and the Learn Agent. "
        "Use the Todo Agent for task management and the Learn Agent for retrieving learning items and returning it to the user."
    ),
    tools=[
        TODO_AGENT.as_tool(
            tool_name="todo_agent",
            tool_description="A tool for managing tasks using the Todo API"
        ),
        RAG_AGENT.as_tool(
            tool_name="rag_agent",
            tool_description="A tool for providing answers regarding user's learning items"
        )
    ]
)

This lets the manager agent use both the Todo Agent and the RAG Agent as needed.

To process multiple user requests, we use a loop. Users rarely stop after one question — they interact in a sequence. The loop keeps asking for input, processes it, and stops only when the user says so.

In this setup, the orchestration loop is implemented in a function called run_manager_agent, which takes a list of user requests and processes them one by one. Here’s how it looks:

# manager.py

def run_manager_agent(requests):
    build_rag()
    
    input_index = 0
    while True:
        if input_index >= len(requests):
            print("No more user requests. Exiting the manager agent.")
            break

        user_input = requests[input_index]
        input_index += 1
        if user_input.lower() in ["exit", "quit"]:
            print("Exiting the manager agent.")
            break

        result = Runner.run_sync(MANAGER_AGENT, user_input)
        print(f"Manager Agent: {result.final_output}")

And you call this function from your main script:

# solution.py

from manager import run_manager_agent

if __name__ == '__main__':    
    user_inputs = [
        "List all my tasks",
        "Create a new task with title 'Learn Python' and description 'Complete the Python course'",
        "What are my learning plans for React",
        "exit"
    ]

    run_manager_agent(user_inputs)

• The loop simulates a conversation with a list of user inputs.
• “exit” or “quit” ends the loop.
• Otherwise, the manager agent processes the input and prints the result.

This pattern is common in chatbots and interactive tools.

How does the manager agent pick the right sub-agent? The orchestration logic is in the tools. Each tool wraps a sub-agent’s functionality. The manager agent analyzes the user request and picks the right tool.

For example, “List all my tasks” goes to the Todo Agent. “What are my learning plans for React?” goes to the RAG Agent.

Tools are registered like this:

tools=[
    TODO_AGENT.as_tool(
        tool_name="todo_agent",
        tool_description="A tool for managing tasks using the Todo API"
    ),
    RAG_AGENT.as_tool(
        tool_name="rag_agent",
        tool_description="A tool for providing answers regarding user's learning items"
    )
]

Delegation happens here:

result = Runner.run_sync(MANAGER_AGENT, user_input)  # result contains the output from the chosen sub-agent

After a sub-agent finishes, the manager agent collects the result and returns it to the user — like a project manager reporting back to a client.

In our example, the result is printed:

print(f"Manager Agent: {result.final_output}")

Note: The manager agent’s response is not just a raw JSON object. Instead, it is a nicely formatted LLM response, often in natural language, summarizing or presenting the information in a user-friendly way.

A full example:

from manager import run_manager_agent

if __name__ == '__main__':    
    user_inputs = [
        "List all my tasks",
        "Create a new task with title 'Learn Python' and description 'Complete the Python course'",
        "What are my learning plans for React",
        "exit"
    ]

    run_manager_agent(user_inputs)

Example output:

Manager Agent: Here are your current tasks:
1. Read Chapter 7 of 'Clean Code' — focus on writing small, single-purpose functions.
2. Experiment with React's useContext by creating a theme toggler component.
...

Manager Agent: Created a new task:
- Title: Learn Python
- Description: Complete the Python course

Manager Agent: Your learning plan for React includes:
- Experiment with React's useContext by creating a theme toggler component.
- Figure out the difference between React Query and Redux for async data handling.
...

Exiting the manager agent.

Running this, you’ll see the manager agent process each input, delegate to the right sub-agent, and print results — until “exit.”

You’ve learned how to orchestrate multiple agents in a loop using a manager agent. We covered:

• The purpose and structure of a manager agent
• Processing a sequence of user requests in a loop
• How the manager agent delegates to sub-agents
• Collecting and returning results in a user-friendly, LLM-generated format

This pattern is key for scalable, maintainable multi-agent systems.

Now it’s your turn! Next, you’ll practice building and running your own orchestration loop. You’ll coordinate agents, process user requests, and return results — just like in a real AI system. Let’s get started!