INTERMEDIATE · 8 MODULES · 64 LESSONS

Agent Memory and State

Give your agent a memory that survives the end of a session, so it remembers each user, updates what changed, and forgets when asked.

For you if
You've built an agent with tools, and every new session it forgets everything.
By the end
You'll know what to store, how to retrieve what's relevant when a session opens, and when you need semantic search.
You need
Basic Python and SQL, and an agent with tool calling under your belt. No API key needed.
  1. 01Why agents forget between sessions8 LESSONS
    1. Module 1: Why agents forget between sessions
    2. Short-term memory is the `messages` list
    3. The limit: when the process ends
    4. A real demo: two separate processes
    5. Conversation memory vs. document memory
    6. The canonical case: Ana and Reservo
    7. What must survive the session
    8. Mini-project: prove the agent forgets
  2. 02Types of memory (working, episodic, semantic)8 LESSONS
    1. Module 2: Types of memory (working, episodic, semantic)
    2. Working memory: the short-term recap
    3. Long-term memory: what persists
    4. Episodic memory: what happened
    5. Semantic memory: facts and preferences
    6. The research: Generative Agents and MemGPT
    7. Classifying Ana's events
    8. Mini-project: sort events into memory types
  3. 03The persistent memory store8 LESSONS
    1. Module 3: The persistent memory store
    2. Why SQLite and not in-memory
    3. The schema: episodes and facts
    4. Writing with one connection, reading with another
    5. The episodes table
    6. The member_facts table
    7. Diego enters the picture: filtering by member
    8. Mini-project: a persistent store for Ana
  4. 04What to save (extracting facts, not transcripts)8 LESSONS
    1. Module 4: What to save (extracting facts, not transcripts)
    2. Why NOT the raw transcript
    3. Extracting facts from `tool_result`
    4. The `extract_facts` function
    5. Episodes vs. facts: what's worth persisting
    6. Writing Ana's session 1 to the store
    7. Deterministic extraction vs. LLM extraction
    8. Mini-project: persist a complete session
  5. 05Retrieving relevant memory8 LESSONS
    1. Module 5: Retrieving relevant memory
    2. Retrieval by member key
    3. Retrieval by recency
    4. Retrieval by keyword matching (lexical)
    5. The lexical limit: it isn't semantic
    6. Measuring retrieval recall
    7. Combining retrieval strategies
    8. Mini-project: retrieving Ana's memory
  6. 06Updating, expiring, and forgetting memory8 LESSONS
    1. Module 6: Updating, expiring, and forgetting memory
    2. Memory changes: `update_fact`
    3. The `updated_at` timestamp
    4. Expiring memory with a TTL
    5. Filtering expired facts on read
    6. Really forgetting: `forget_member`
    7. Privacy and the right to be forgotten
    8. Mini-project: updating, expiring, and forgetting
  7. 07Injecting memory into a new session8 LESSONS
    1. Module 7: Injecting memory into a new session
    2. The write-at-end, read-at-start cycle
    3. `format_memory_block`: giving the text its shape
    4. Injecting into the `system`
    5. Injecting into the initial `messages`
    6. The full cycle: from session 1 to session 2
    7. The boundary with `context-engineering-guide`
    8. Mini-project: a memory-aware Reservo agent
  8. 08Project: a Reservo agent with member memory8 LESSONS
    1. Module 8: Project: a Reservo agent with member memory
    2. The full memory cycle
    3. Session 1: book and remember
    4. Between sessions: the store persists
    5. Session 2: recall and personalize
    6. Diego and the member filter
    7. What your memory system still needs
    8. Project: ship the memory-aware agent
Reviews

What students say

These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.

No approved reviews yet.

Be the first to share your experience!

SEC. 06 · THE STUDIO

Why this studio exists

For decades, building software belonged to technical profiles with years of training, and getting a digital product into the real world took companies months or years. No-code and AI have narrowed that gap, but the knowledge is still held by a few.

Tech Benders exists to open that knowledge up, so business teams and non-technical teams can put their ideas into production with the right technical decisions behind them. AI does what you ask of it. Without a technical base, what it builds may not scale with your company’s ecosystem, and its costs can run away over time.

The team knows the pains of large organizations and the speed at which they have to move. It brings solution architecture, data engineering, product built end to end from back end to front end, and daily work with AI. Software that solves what you need in days, not months, with the cost of AI kept in check.

Founders

The studioRead about Tech Benders →

Write to ushi@techbenders.io

Made with Wislab