1tools = [{
2    "type": "function",
3    "function": {
4        "name": "get_weather",
5        "description": "Get current weather for a location",
6        "parameters": {
7            "type": "object",
8            "properties": {
9                "location": {"type": "string", "description": "City name"},
10                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}

11            },
12            "required": ["location"]
13        }
14    }
15}]

1# User asks: "What's the weather like in Hanover, NH?"
2
3# Step 1: LLM generates a function call (not free text)
4response = {
5    "function_call": {
6        "name": "get_weather",
7        "arguments": '{"location": "Hanover, NH", "unit": "fahrenheit"}'
8    }
9}
10
11# Step 2: System executes the function
12result = get_weather(location="Hanover, NH", unit="fahrenheit")
13# Returns: {"temperature": 28, "condition": "snowy"}
14
15# Step 3: Result is fed back to the LLM
16# LLM generates: "It's 28°F and snowy in Hanover, NH right now."

1Question: "What is the elevation of the city where Dartmouth College
2           is located?"
3
4Thought 1: I need to find which city Dartmouth College is in.
5Action 1:  search("Dartmouth College location")
6Obs 1:     Dartmouth College is in Hanover, New Hampshire.
7
8Thought 2: Now I need the elevation of Hanover, NH.
9Action 2:  search("Hanover New Hampshire elevation")
10Obs 2:     Hanover, NH has an elevation of 531 feet (162 m).
11
12Thought 3: I have the answer.
13Action 3:  finish("531 feet (162 meters)")

Each Thought is the model reasoning; each Action is a tool call; each Obs is the tool's response.

1Original:  "The Eiffel Tower is 330 meters tall."
2Annotated: "The Eiffel Tower is [QA("height of Eiffel Tower") → 330]
3            meters tall."
4
5Original:  "The population of France is about 67 million."
6Annotated: "The population of France is about
7            [Search("France population") → 67 million] ."

The model learns to insert [Tool(query) → result] at positions where the tool call improves next-token prediction. At inference time, the system intercepts these calls and executes them.

1import openai, json
2
3TOOLS = {
4    "search": lambda q: web_search(q),
5    "calculate": lambda expr: eval(expr),  # Simplified!
6    "finish": lambda answer: answer,
7}
8
9def agent_loop(question, max_steps=5):
10    messages = [{"role": "user", "content": question}]
11    for step in range(max_steps):
12        response = openai.chat.completions.create(

13            model="gpt-4", messages=messages, tools=tool_definitions
14        )
15        msg = response.choices[0].message
16        if msg.tool_calls:
17            for call in msg.tool_calls:
18                fn = TOOLS[call.function.name]
19                result = fn(**json.loads(call.function.arguments))
20                messages.append({"role": "tool", "content": str(result),
21                                 "tool_call_id": call.id})
22        else:
23            return msg.content  # Final answer (no tool call)
24    return "Max steps reached"

1User: "Compare the GDP per capita of the US and Japan in 2023,
2       and calculate the ratio."
3
4Step 1 - Thought: I need GDP per capita data for both countries.
5Step 1 - Action:  search("US GDP per capita 2023")
6Step 1 - Result:  "$76,329"
7
8Step 2 - Action:  search("Japan GDP per capita 2023")
9Step 2 - Result:  "$33,950"
10
11Step 3 - Thought: Now I can calculate the ratio.
12Step 3 - Action:  calculate("76329 / 33950")
13Step 3 - Result:  2.248
14
15Step 4 - Answer:  "US GDP per capita ($76,329) is approximately
16                   2.25x Japan's ($33,950) in 2023."

The agent decomposed the task, gathered data with search, computed the ratio with a calculator, and synthesized a final answer.