# The Five Components That Constitute Context in an LLM API Call for an Agent

> Understand the five essential components of LLM API calls for agents: System Prompt, Tool Definitions, User Messages, Assistant Messages, and Tool Results. Learn how they enable multi-turn reasoning.

- Repository: [Bojie Li/ai-agent-book](https://github.com/bojieli/ai-agent-book)
- Tags: deep-dive
- Published: 2026-08-26

---

**In the `bojieli/ai-agent-book` architecture, every LLM API call for an agent is built from five distinct components: the System Prompt, Tool Definitions, User Messages, Assistant Messages, and Tool Results, which together form a static prefix and a dynamic trajectory that enables robust multi-turn reasoning.**

Building effective AI agents requires precise control over what the language model sees during each inference cycle. According to the source code and documentation in `bojieli/ai-agent-book`, the **five components that constitute context in an LLM API call for an Agent** are split between immutable configuration and evolving conversation state. This architecture determines how agents maintain state, invoke tools, and generate coherent responses across extended interactions.

## The Architecture: Static Prefix vs. Dynamic Trajectory

The context window in an agent system is not monolithic. As defined in [`book-en/chapter1.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter1.md) (lines 149-167), the five components are organized into two functional groups:

- **Static Prefix**: Components that remain constant across API calls, defining the agent's identity and capabilities
- **Trajectory**: Components that grow with each interaction, representing the evolving state of the conversation

This division ensures that the model receives both persistent instructions (the prefix) and current situational awareness (the trajectory) on every call.

## Component 1: System Prompt (Static)

The **System Prompt** provides the agent’s identity, high-level instructions, and immutable behavioral rules. According to [`book-en/chapter1.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter1.md) at line 167, this is delivered via the `[System]` message role and establishes the foundation for role-aware agent behavior.

This component never changes during a conversation session, ensuring consistent personality and constraint enforcement regardless of how long the interaction continues.

## Component 2: Tool Definitions (Static)

**Tool Definitions** declare the functions, APIs, or capabilities the agent can invoke. As documented in [`book-en/chapter2.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter2.md) (lines 56-58), these are delivered via the top-level `tools` field in the request body, separate from the message array.

These definitions include JSON schemas describing function signatures, required parameters, and descriptions that help the model understand when and how to invoke external capabilities. Like the system prompt, tool definitions typically remain static throughout a session.

## Component 3: User Messages (Trajectory)

**User Messages** represent the human operator’s latest query or ongoing conversation input. This component is part of the *trajectory* that expands with each turn, as noted in [`book-en/chapter1.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter1.md) at line 167.

Each new user input appends to this sequence, providing the model with the current objective or question that requires processing.

## Component 4: Assistant Messages (Trajectory)

**Assistant Messages** contain the agent’s prior replies, including any Chain-of-Thought (CoT) reasoning or tool-call statements generated in previous turns. This trajectory component, referenced at line 167 of [`book-en/chapter1.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter1.md), allows the model to maintain context about what it has already said or decided.

These messages may include `function_call` objects indicating which tools the agent previously attempted to invoke, critical for maintaining logical continuity across multi-step reasoning chains.

## Component 5: Tool Results (Trajectory)

**Tool Results** carry the outputs returned by invoked tools—such as search results, database queries, or calculation returns. As the third element of the trajectory identified in [`book-en/chapter1.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter1.md) (line 167), these messages typically use the `role: "tool"` designation and contain the actual data the agent requested in previous steps.

Without this component, the agent would have no mechanism to incorporate external data into its reasoning process.

## Implementing All Five Components in API Calls

When constructing an LLM API request for an agent, you must assemble both the static prefix and the trajectory. The following examples demonstrate the complete five-component structure as implemented in the `bojieli/ai-agent-book` codebase.

### Python Implementation (OpenAI-Compatible)

```python
import json
import openai

# 1️⃣ System prompt (static prefix)

system_prompt = {
    "role": "system",
    "content": "You are a helpful assistant that can search the web and summarize articles."
}

# 2️⃣ Tool definitions (static prefix)

tools = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web for a query.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"}
                },
                "required": ["query"]
            },
        },
    }
]

# 3️⃣ User message (trajectory)

user_msg = {"role": "user", "content": "Find the latest research on quantum‑resistant cryptography."}

# 4️⃣ Assistant message (trajectory) – from a prior turn

assistant_msg = {
    "role": "assistant",
    "content": "Sure, let me look that up for you.",
    "function_call": {"name": "web_search", "arguments": json.dumps({"query": "quantum‑resistant cryptography"})}
}

# 5️⃣ Tool result (trajectory) – result of the previous function call

tool_result = {
    "role": "tool",
    "name": "web_search",
    "content": "Top result: https://example.com/qc‑paper.pdf – a 2024 paper on lattice‑based cryptography."
}
    
payload = {
    "model": "gpt-4o-mini",
    "messages": [system_prompt, user_msg, assistant_msg, tool_result],
    "tools": tools,
    "temperature": 0.2,
}
response = openai.ChatCompletion.create(**payload)

```

This implementation maps the **four message roles** (system, user, assistant, tool) plus the **tools field** to the five components described in [`book-en/chapter2.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter2.md).

### Raw JSON Payload Structure

```json
{
  "model": "gpt-4o-mini",
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "weather",
        "description": "Get current weather for a city.",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {"type": "string", "description": "City name"}
          },
          "required": ["city"]
        }
      }
    }
  ],
  "messages": [
    {"role": "system", "content": "You are a weather‑aware assistant."},
    {"role": "user", "content": "What's the temperature in Paris today?"},
    {"role": "assistant", "content": "Let me check that for you.", "function_call": {"name":"weather","arguments":"{\"city\":\"Paris\"}"}},
    {"role": "tool", "name": "weather", "content": "Paris: 12°C, partly cloudy."}
  ],
  "temperature": 0.0
}

```

The JSON structure explicitly separates the **Tool Definitions** (top-level `tools` array) from the message-based components, aligning with the architecture described in [`slides/lesson-07.md`](https://github.com/bojieli/ai-agent-book/blob/main/slides/lesson-07.md) regarding context window composition.

## Why These Five Components Are Essential

According to the ablation study referenced in [`book-en/chapter1.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter1.md), removing any one of these five components (except the system prompt, which is essential for basic role awareness) degrades agent performance. The **static prefix** ensures the model understands its capabilities and constraints, while the **trajectory** enables step-by-step reasoning and incorporation of external data.

The [`slides/lesson-03.md`](https://github.com/bojieli/ai-agent-book/blob/main/slides/lesson-03.md) file emphasizes that omitting **Tool Results** breaks the agent's ability to utilize external knowledge, while missing **Assistant Messages** disrupts the logical chain of multi-turn problem solving.

## Summary

- **System Prompt**: Establishes agent identity and immutable rules via the `system` role
- **Tool Definitions**: Declares available functions via the top-level `tools` field
- **User Messages**: Captures current human input via the `user` role
- **Assistant Messages**: Preserves agent reasoning history via the `assistant` role
- **Tool Results**: Incorporates external data returns via the `tool` role

Together, these five components form the complete context mechanism that powers robust agent architectures.

## Frequently Asked Questions

### What happens if I omit the Tool Results component from the API call?

Removing **Tool Results** severs the feedback loop between the agent and external tools. As documented in [`book-en/chapter1.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter1.md), the model will not see the output of any functions it calls, effectively rendering those tools useless and preventing the agent from incorporating real-time data into its responses.

### How do the five components map to OpenAI's API structure?

According to [`book-en/chapter2.md`](https://github.com/bojieli/ai-agent-book/blob/main/book-en/chapter2.md) (lines 56-58), the mapping follows a "four message roles + tools field" pattern: the **System Prompt**, **User Messages**, **Assistant Messages**, and **Tool Results** correspond to message roles, while **Tool Definitions** occupy the separate `tools` array in the request body.

### Can the System Prompt and Tool Definitions change during a conversation?

Technically possible but architecturally discouraged. These components form the **static prefix** that defines the agent's consistent identity and capabilities across the session. Changing them mid-conversation can lead to inconsistent behavior, though advanced implementations in [`slides/lesson-07.md`](https://github.com/bojieli/ai-agent-book/blob/main/slides/lesson-07.md) suggest dynamic tool registration for specific use cases.

### Why are Assistant Messages necessary if I already have User Messages?

**Assistant Messages** preserve the agent's own reasoning steps and tool-call attempts, which is essential for maintaining logical continuity. Without this trajectory component (specifically the `function_call` data), the model cannot reference its previous decisions or understand which tools it has already invoked, leading to redundant or contradictory actions.