Lab Walkthrough Agent Memory in Action

Time for hands-on practice. In this lab you’ll run a multi-turn agent conversation, watch the messages list grow with every turn, and implement a sliding-window memory manager to control token usage, cost, and latency.

A dark slide that reads "AGENT MEMORY IN ACTION" in large yellow pixelated text. Above it is a turquoise "HANDS-ON LAB" badge and below is the subtitle "Multi-turn conversation · Watch memory grow."

What you’ll accomplish

Run a multi-turn conversation with an agent that uses a calendar tool.
Observe how the conversation history (messages) grows and why that matters.
Implement trim_history() — a sliding-window memory manager that preserves the system prompt and keeps the most recent N messages.

Prerequisites

Python 3.11 with a virtual environment active.
The OpenAI SDK is pre-installed. See: OpenAI API (Python)
Working directory: /root/code
Repo already contains:
- agent_memory.py — the agent loop wired up and importing a calendar tool from tools.py
- tools.py — contains tools and execute_tool

Quick file reference:

File	Purpose
`agent_memory.py`	Agent loop: messages list, run_agent function, and where you will set the system prompt and add questions
`tools.py`	Tool implementations (e.g., `calendar`) used by the agent
`requirements.txt`	Pre-installed SDKs (OpenAI SDK already present)

Starter client snippet (already in the repo)

The repo contains this OpenAI client setup. You do not need to change it, but it shows how the client is instantiated:

import os
import json
from openai import OpenAI
from tools import tools, execute_tool

client = OpenAI(
    api_key=os.getenv("OPENAI_API_KEY"),
    base_url=os.getenv("OPENAI_API_BASE"),
)

1) Set the system prompt

Open agent_memory.py. Locate the messages list and the system prompt variable at the top of the conversation history. Set a concise system prompt to define the agent’s identity and tool usage expectations. Example guidance:

Tell the agent it is a helpful personal assistant.
Instruct it to use tools (like the calendar tool) when it needs verified or real data.
Keep the system prompt as the very first message in messages so the trimming logic can always preserve it.

Example system prompt assignment (place this as messages[0]):

system_prompt = {
    "role": "system",
    "content": (
        "You are a helpful personal assistant. Use available tools (e.g., the calendar tool) "
        "to fetch or verify real data when appropriate. Always be concise and confirm when you use a tool."
    ),
}

messages = [system_prompt]

Why this matters: the trimming function will always preserve messages[0] (the system prompt), so keep it compact and authoritative.

2) Add conversational questions that test memory

Add a sequence of user questions that force the agent to rely on conversational state across turns. Below is an example set of five questions. Append each user question to messages, call the agent, then observe the growth of messages. Example loop to add in agent_memory.py:

questions = [
    "What's on my calendar today?",
    "Tell me about the standup.",
    "What time is my dentist?",
    "Am I free at 3pm?",
    "Summarise my day.",
]

for q in questions:
    messages.append({"role": "user", "content": q})
    answer = run_agent(messages)   # run_agent should call the API and append assistant response
    print(f"Q: {q}")
    print(f"A: {answer}")
    print(f"Messages in history: {len(messages)}")

Example run output you might see:

root@controlplane ~/code via 🐍 v3.11 (venv) python3 agent_memory.py
Q: What's on my calendar today?
A: You have a standup at 10am and a dentist appointment at 2pm.

Messages in history: 4

Q: Tell me about the standup.
A: Your standup is at 10am — a daily team sync.

Messages in history: 8

Q: What time is my dentist?
A: Your dentist appointment is at 2pm.

Messages in history: 12

Note: Every new user and assistant turn increases the messages list. If run_agent appends assistant responses, your list grows quickly and every API call will include that full history.

3) Why trimming is necessary

Long message histories:

Use more tokens per API call
Increase cost and latency
Can hit the model context limit

A simple and effective strategy: sliding-window memory that keeps the system prompt plus the most recent N-1 user/assistant messages.

4) Implement a sliding-window memory manager

Create a function named trim_history in agent_memory.py. Default max_messages=6 is a good starting point (1 system message + 5 recent turns).

def trim_history(messages, max_messages=6):
    """
    Keep the system prompt (messages[0]) and the most recent (max_messages - 1)
    user/assistant messages. If the messages list is already short enough,
    return it unchanged.
    """
    if len(messages) > max_messages:
        # Preserve the first (system) message and keep the most recent (max_messages - 1) other messages
        return [messages[0]] + messages[-(max_messages - 1):]
    return messages

Where to call it:

After appending the assistant response to messages, and before the next user turn, call trim_history(messages, max_messages=6).

Example integration inside the interaction loop:

# After the assistant's response is appended
messages = trim_history(messages, max_messages=6)

# Then the next iteration will append the next user message

This keeps the system prompt intact as messages[0] while limiting the rest of the retained history to the most recent conversation turns.

Keep the system prompt at messages[0]. The trimming function assumes that the first message is the agent’s system prompt and always preserves it.

5) Re-run the script and observe

Run agent_memory.py again after adding trim_history and integrating it into your loop. You should observe the message count stabilise around max_messages (6 by default). The agent will continue to act coherently because:

The system instruction remains preserved.
The most recent turns (the most relevant context) are kept.

This sliding-window approach provides a simple, production-ready memory manager:

System prompt always preserved
History capped to control token usage
Reduces cost and latency while keeping recent context

LLM Fundamentals

Tools and Workflows

Building AI Agents

Introduction

Production & OpenClaw

Lab Walkthrough Agent Memory in Action

What you’ll accomplish

Prerequisites

Starter client snippet (already in the repo)

1) Set the system prompt

2) Add conversational questions that test memory

3) Why trimming is necessary

4) Implement a sliding-window memory manager

5) Re-run the script and observe

Further reading and references

Watch Video

Practice Lab

​What you’ll accomplish

​Prerequisites

​Starter client snippet (already in the repo)

​1) Set the system prompt

​2) Add conversational questions that test memory

​3) Why trimming is necessary

​4) Implement a sliding-window memory manager

​5) Re-run the script and observe

​Further reading and references

Watch Video

Practice Lab

What you’ll accomplish

Prerequisites

Starter client snippet (already in the repo)

1) Set the system prompt

2) Add conversational questions that test memory

3) Why trimming is necessary

4) Implement a sliding-window memory manager

5) Re-run the script and observe

Further reading and references