Lab Walkthrough Wire Up Components

Five components. That’s all an agent needs: a model, tools, memory, a system prompt, and an orchestration loop. In this lesson we’ll wire all five together in a single Python script and observe them working as one. This walkthrough uses the OpenAI Python SDK and demonstrates a simple tool-driven agent that checks a calendar.

Environment and setup

Prerequisites (already prepared in the environment):

Python 3.11
A virtual environment activated
The OpenAI Python SDK installed (https://github.com/openai/openai-python)
Working directory: /root/code

Create a new file named agent_components.py and follow the steps below.

Overview: the five components

Component	Role	Example / Where it appears
Model	The LLM that reasons and decides when to call tools	`model = "openai/gpt-4.1-mini"`
Tools	Function definitions the model may request (metadata visible to the model)	`tools = [ { "type": "function", "function": { ... } } ]`
Handlers	Your Python functions that actually execute tool logic	`def check_calendar(date):`
Memory / Messages	Conversation state shared with the model (system, user, assistant, tool messages)	`messages = [...]`
Orchestration loop	Glue that sends messages & tools to the model, executes handlers for tool calls, and feeds results back	the `while True:` loop shown below

Step 1 — Skeleton and client initialization

Start with the basic imports and client setup: create an OpenAI client using your API key and base URL from environment variables, select the model, and initialize conversation messages with a system message.

from openai import OpenAI
import os
import json

client = OpenAI(
    api_key=os.environ["OPENAI_API_KEY"],
    base_url=os.environ["OPENAI_API_BASE"]
)

model = "openai/gpt-4.1-mini"

messages = [
    {
        "role": "system",
        "content": "You are a helpful personal assistant. Use your tools when you need real data."
    }
]

The system prompt above is component one. It gives the agent an identity and instructs it to use tools rather than guessing when it needs real data.

Step 2 — Define a tool (and its handler)

Add a tools list that describes what the model may call. This is the metadata the model sees. Separately, implement a handler function in Python that executes the requested action and returns the result.

Tool metadata (name, description, and parameters) is provided to the model.
Handlers perform the real work and return text results to be appended back into the conversation.

tools = [
    {
        "type": "function",
        "function": {
            "name": "check_calendar",
            "description": "Check calendar",
            "parameters": {
                "type": "object",
                "properties": {
                    "date": {"type": "string"}
                },
                "required": ["date"]
            }
        }
    }
]

def check_calendar(date):
    # Example hardcoded calendar items for the provided date
    return "10:00 AM: Team stand-up\n2:00 PM: Dentist"

Remember: the model reads the tool definition (the tools list) and may decide to call check_calendar. Your code must provide the handler (the check_calendar function) to produce the actual result.

Step 3 — Add a user message

Append a user message that will trigger the agent to use tools as needed.

messages.append({"role": "user", "content": "What's on my calendar today?"})

Step 4 — Orchestration loop

The orchestration loop sends messages and tools metadata to the model, inspects the model response for tool calls, executes handlers when requested, and feeds the results back to the conversation until the model returns a final answer.

while True:
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        tools=tools
    )

    finish_reason = response.choices[0].finish_reason
    msg = response.choices[0].message
    messages.append(msg)

    if finish_reason == "stop":
        # Model has provided a final answer
        print(msg.content)
        break

    if finish_reason == "tool_calls":
        # The model requested one or more tool calls
        for tc in msg.tool_calls:
            name = tc.function.name
            args = json.loads(tc.function.arguments)
            # Call the matching handler in your code
            if name == "check_calendar":
                result = check_calendar(**args)
            else:
                result = f"Unhandled tool: {name}"
            # Append the tool result back into the conversation as a tool message
            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "content": result
            })

Step 5 — Run the script

From the terminal in /root/code, run:

python3 agent_components.py

What happens:

The model receives the system prompt and user question.
Based on the tools metadata, the model may decide to call check_calendar.
Your orchestration loop detects the tool call, executes the check_calendar handler, and appends the handler output as a tool message.
The model consumes the tool output and returns a final assistant response that you print.

Expected final output (example):

10:00 AM: Team stand-up
2:00 PM: Dentist

Notes and clarifications

The tools list describes the functions the model may call. The model sees the metadata (name, description, and parameter schema) but does not execute code itself.
Handlers are implemented in your runtime (Python in this example). They can call APIs, access databases, or return simulated responses.
The orchestration loop is the glue: it passes conversation state and tool definitions to the model, inspects for tool calls, runs handlers, and appends tool output so the model can finish its response.
For production agents, implement robust error handling, retries, input validation against the declared parameters schema, and logging of tool calls and results.

Keep your API key and base URL secure. Never commit them to source control; prefer environment variables or secrets managers. If keys are exposed, rotate them immediately.

Quick reference links

OpenAI Python SDK: https://github.com/openai/openai-python
OpenAI API docs: https://platform.openai.com/docs
Best practices for building tool-enabled agents: see official platform guides and SDK examples

This example demonstrates a minimal, clear pattern for building a tool-enabled Python agent: define what the model can call, implement the handlers, and run an orchestration loop to coordinate model decisions and tool execution.

LLM Fundamentals

Tools and Workflows

Building AI Agents

Introduction

Production & OpenClaw

Lab Walkthrough Wire Up Components

Environment and setup

Overview: the five components

Step 1 — Skeleton and client initialization

Step 2 — Define a tool (and its handler)

Step 3 — Add a user message

Step 4 — Orchestration loop

Step 5 — Run the script

Notes and clarifications

Quick reference links

Watch Video

​Environment and setup

​Overview: the five components

​Step 1 — Skeleton and client initialization

​Step 2 — Define a tool (and its handler)

​Step 3 — Add a user message

​Step 4 — Orchestration loop

​Step 5 — Run the script

​Notes and clarifications

​Quick reference links

Watch Video

Environment and setup

Overview: the five components

Step 1 — Skeleton and client initialization

Step 2 — Define a tool (and its handler)

Step 3 — Add a user message

Step 4 — Orchestration loop

Step 5 — Run the script

Notes and clarifications

Quick reference links