Controlling Loops of Agentic Tool-Use

Introduction: From Manual Steps to Automated Loops

In the previous lesson, you built a tool execution pattern where you made two separate API calls to complete a calculation task. This manual approach helped you understand context flow, but it is not practical for production systems where tasks might require many steps. In this lesson, you will build an agentic loop that automates this process, implementing Factor 8 (Own your control flow) by giving your code full control over execution, and Factor 9 (Compact Errors into Context Window) by feeding structured failure information back to the model. By the end, you will have an agent that handles multi-step tasks like "What is 15 + 27? Then multiply the result by 3" without any manual intervention.

Setting Up Loop Control Variables

Before building the loop, you need to establish control variables that manage execution boundaries and track progress. These variables implement Factor 8 by putting your code in charge of when the loop continues and when it stops. Python # Set up loop control variables max_steps = 5 step = 0 done = False final_answer = None These control variables work together to manage your agent's execution lifecycle: The max_steps variable acts as a safety boundary that prevents runaway execution, which is critical for production systems where you need predictable resource usage and cost control. The step counter tracks how many iterations have occurred, helping with debugging and observability. The done flag serves as your completion signal that gets set to True when the model calls final_answer . The final_answer variable stores the result once it is provided. The max_steps boundary is particularly important because it ensures your agent cannot consume unlimited API calls or compute resources. The combination of done and step gives you both logical completion (when the task finishes) and physical completion (when you hit resource limits), allowing your system to handle both successful completions and edge cases gracefully.

Building the While Loop Condition

The core agent loop uses a while condition that combines your completion flag and safety boundary to determine when execution should continue. Python# Main agent loop: continue until done or max steps reached while not done and step < max_steps: step += 1 print(f"\n--- Step {step} ---") The condition not done and step < max_steps ensures that the loop stops either when the agent signals completion or when you hit your safety limit. At the start of each iteration, you increment the step counter and print a separator to make the execution flow visible during development.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Dispatching to Functions with Match Statements

You use a match statement wrapped in a try block to execute the corresponding Python function based on the function_name.

Python

            # Execute tools and capture result for printing
            try:
                match function_name:
                    case "final_answer":
                        result = args.get("answer")
                        final_answer = result
                        output = json.dumps({"status": "reported"})
                        done = True
                    case "add":
                        result = add(**args)
                        output = json.dumps({"result": result})
                    case "multiply":
                        result = multiply(**args)
                        output = json.dumps({"result": result})
                    case _:
                        result = f"Tool {function_name} not found"
                        output = json.dumps({"error": result})

            # Execute tools and capture result for printing
            try:
                match function_name:
                    case "final_answer":
                        result = args.get("answer")
                        final_answer = result
                        output = json.dumps({"status": "reported"})
                        done = True
                    case "add":
                        result = add(**args)
                        output = json.dumps({"result": result})
                    case "multiply":
                        result = multiply(**args)
                        output = json.dumps({"result": result})
                    case _:
                        result = f"Tool {function_name} not found"
                        output = json.dumps({"error": result})

The match statement dispatches to the correct Python function using **args to unpack the parsed arguments as keyword parameters. The final_answer case is special because it signals completion by setting done = True and storing the result, rather than performing a calculation. For calculation functions like add and multiply, you execute them and format their results as JSON using json.dumps. The default case _ handles unexpected tool names by creating an error message, preventing crashes if the model requests a non-existent tool.

Viewing the Complete Loop Structure

Now that you have built each piece of the loop individually, it is helpful to see the complete structure in one place. The following code shows the entire while loop including all the sections you built: the API call, function call processing, context recording, tool execution with error handling, result recording, and the completion break.

Python

# Main agent loop: continue until done or max steps reached
while not done and step < max_steps:
    step += 1
    print(f"\n--- Step {step} ---")

    # Call the LLM with current context
    response = openai.responses.create(
        model="gpt-5",
        instructions=system_prompt,
        input=context,
        tools=tool_schemas,
        tool_choice="required",
        reasoning={"effort": "low"}
    )

    # Process each item in the response output
    for item in response.output:
        if item.type == "function_call":
            function_name = item.name
            args = json.loads(item.arguments)

            print(f"Calling function: {function_name}({args})")

            # Add function call to context
            context.append({
                "type": "function_call",
                "name": function_name,
                "arguments": item.arguments,
                "call_id": item.call_id
            })

            # Execute tools and capture result for printing
            try:
                match function_name:
                    case "final_answer":
                        result = args.get("answer")
                        final_answer = result
                        output = json.dumps({"status": "reported"})
                        done = True
                    case "add":
                        result = add(**args)
                        output = json.dumps({"result": result})
                    case "multiply":
                        result = multiply(**args)
                        output = json.dumps({"result": result})
                    case _:
                        result = f"Tool {function_name} not found"
                        output = json.dumps({"error": result})
            except Exception as e:
                result = f"Error: {e}"
                output = json.dumps({"error": str(e)})

            print(f"Result: {result}")

            # Add function output to context
            context.append({
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": output
            })

            # Exit processing if final answer reached
            if done:
                break

# Main agent loop: continue until done or max steps reached
while not done and step < max_steps:
    step += 1
    print(f"\n--- Step {step} ---")

    # Call the LLM with current context
    response = openai.responses.create(
        model="gpt-5",
        instructions=system_prompt,
        input=context,
        tools=tool_schemas,
        tool_choice="required",
        reasoning={"effort": "low"}
    )

    # Process each item in the response output
    for item in response.output:
        if item.type == "function_call":
            function_name = item.name
            args = json.loads(item.arguments)

            print(f"Calling function: {function_name}({args})")

            # Add function call to context
            context.append({
                "type": "function_call",
                "name": function_name,
                "arguments": item.arguments,
                "call_id": item.call_id
            })

            # Execute tools and capture result for printing
            try:
                match function_name:
                    case "final_answer":
                        result = args.get("answer")
                        final_answer = result
                        output = json.dumps({"status": "reported"})
                        done = True
                    case "add":
                        result = add(**args)
                        output = json.dumps({"result": result})
                    case "multiply":
                        result = multiply(**args)
                        output = json.dumps({"result": result})
                    case _:
                        result = f"Tool {function_name} not found"
                        output = json.dumps({"error": result})
            except Exception as e:
                result = f"Error: {e}"
                output = json.dumps({"error": str(e)})

            print(f"Result: {result}")

            # Add function output to context
            context.append({
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": output
            })

            # Exit processing if final answer reached
            if done:
                break

This complete loop structure automatically handles multi-step tasks without any manual intervention between steps. The context flows naturally from one iteration to the next, with each function call and result being recorded so the model can see the complete history at every step.

Introduction: From Manual Steps to Automated Loops

Setting Up Loop Control Variables

Building the While Loop Condition

Join the 1M+ learners on CodeSignal

Making API Calls Inside the Loop

Processing Function Calls in the Response

Recording the Function Call to Context

Dispatching to Functions with Match Statements

Implementing Error Handling with Try-Except

Adding Function Results to Context

Handling Final Answer Completion

Viewing the Complete Loop Structure

Observing Step-by-Step Execution

Adding Post-Loop Summary and Boundary Detection

Summary: Owning Your Control Flow