Memory as an Actively-Invoked Tool
Overview
Implementing agent memory as a set of tools the model explicitly chooses to call, rather than passively prepending all past conversations into every system prompt.
Passive injection degrades performance, causes context overflow, and inflates token costs. Active retrieval forces the agent to consciously look up semantic facts or episodic logs only when needed.
Where used: Production-grade Claude or LangChain agents, Long-running assistants with episodic memory requirements
Why learn this
- You will understand the difference between passive context injection and active memory retrieval.
- You will learn to separate semantic (facts), episodic (experiences), and procedural (instructions) memory.
- You will avoid the common pitfall of a single flat memory store that degrades agent reasoning.
Code walkthrough
def run_agent(user_input):
# Agent starts with a clean prompt and memory access tools
tools = [{'type': 'function', 'function': {'name': 'search_semantic_memory'}}]
response = client.chat.completions.create(
model='gpt-4o',
tools=tools,
messages=[{'role': 'user', 'content': user_input}]
)
# The memory is only loaded IF the agent called the tool
if response.tool_calls:
context = execute_memory_tool(response.tool_calls[0])
return "Memory retrieved: " + context
return "No memory needed."Focus: Notice how the system prompt is clean. The agent must consciously choose to invoke `search_semantic_memory` to access historical context. Helper names are placeholders — the control flow is the point.
Aha moment
def ask_agent():
# User stored their favorite color in memory yesterday
tools = [search_memory_tool]
messages = [{'role': 'user', 'content': 'What is my favorite color?'}]
return invoke_llm(messages, tools)Prediction: The agent will execute a tool call to `search_memory_tool` with the query 'favorite color', and wait for the result before answering.
Common guess: The agent will simply answer with the favorite color because it 'has memory'.
The agent's context window is clean at the start of the turn. It does not possess the memory yet. It must actively use the tool to retrieve the answer from storage.
Common mistakes
- Assuming memory tools inject context automatically: Giving an agent a 'memory tool' doesn't mean it inherently knows past facts. The model must explicitly issue a tool call to read that memory; if it doesn't, the context is completely absent.
- Using a single undifferentiated memory store: Dumping stable user facts (semantic), past conversations (episodic), and agent instructions (procedural) into one flat text file causes retrieval failures, as episodic logs will bury semantic facts.
Recall questions
- What is the fundamental difference between passive memory injection and memory as a tool?
- Name the three types of agent memory.
- If an agent has a memory tool but still claims it doesn't know a previously stored fact, what likely happened?
Understanding checks
An agent has access to `search_semantic_memory`. A user asks, 'What did I say my favorite color was yesterday?' The agent responds, 'I don't know, you haven't told me.' What went wrong in the execution trace?
The agent failed to generate a tool call for `search_semantic_memory` and attempted to answer directly from its empty context.
Because memory is actively invoked rather than passively injected, if the model decides not to use the tool, it has zero access to the historical data.
A developer dumps 50 past chat summaries and 5 core user facts into `memory.txt`. The agent uses a `search_memory` tool but frequently fails to find the core facts. Why?
The episodic memory (chat summaries) buried the semantic memory (core facts), causing the retrieval tool to return irrelevant chunks.
Combining all memory types into a flat structure dilutes the density of important facts, degrading retrieval accuracy.
Practice tasks
Implement an Active Memory Tool
Write a Python dictionary defining an OpenAI-formatted tool called `view_semantic_memory` that takes a `topic` string parameter.
Continue learning
Previous: Context Bloat: Pruning and Compacting Agent State
Previous: Agent Memory: Short vs. Long Term