Free course # Building AI Agents That Remember A free, seven part course on memory and context for AI agents. Framework agnostic, entirely hands on, and built around one agent that you carry from the first lesson to the last. Seven video lessons of ten to fifteen minutes each, every one paired with code you write yourself. - 7 lessons - ~75 minutes - Free, no gate - Python + any LLM API [Start the course on Scaler](https://www.scaler.com/topics/course/agentic-ai/)[See what you will build](https://www.maximem.ai/learn/ai-agent-memory-course#lessons) Why I recorded this ## Memory is a data pipeline and retrieval problem, not a storage problem. An agent that cannot remember is not really an assistant; it is a very articulate search box that starts from zero every morning. Most teams discover this the same way, which is that the demo works beautifully, the second session works less beautifully, and by the second week a user asks "why do I have to tell you this again" and nobody on the team has a good answer. The usual first fix is to push more history into the prompt. That buys a few weeks. Then the [context window](https://www.maximem.ai/glossary/context-window) fills, latency climbs, cost per turn climbs faster, and the model starts losing the one detail that mattered somewhere in the middle of forty thousand [tokens](https://www.maximem.ai/glossary/tokenization) of transcript it did not need. The problem was never that the history was unavailable. The problem is that nothing decided what was worth keeping, nothing resolved the same customer being referred to four different ways, nothing noticed that a fact from March had been quietly replaced in June, and nothing checked whether this particular user was allowed to see what came back. Getting this right is depth work. It is also very learnable, and almost nobody teaches it as its own engineering discipline, which is why I recorded this course and put it out free. Every lesson opens with an agent failing at something it should have known, and ends with you fixing that failure in code. Nothing is theoretical for longer than a few minutes at a time. ## Seven lessons, one agent, all code You are not building seven disconnected demos. You start with a stateless chatbot in the first lesson and finish with a memory-enabled agent that survives a real user across sessions. - ### Free and open. The full course is on Scaler at no cost, with no gate on the assignments. - ### Framework agnostic. Python and an LLM API is the whole prerequisite stack. Nothing here is tied to LangChain, LlamaIndex, or any single vendor, and everything transfers to whatever you already use. - ### Hands on, every lesson. Ten to fifteen minutes of video, then an assignment where you write the thing you just watched. - ### Built to be shipped from. Scoping, tenant isolation, latency, forgetting, evaluation: the parts that decide whether memory survives contact with real customers get their own lessons rather than a footnote. ## Who should take this Developers and ML engineers who are building agents, or who are about to, and who have run into the forgetting problem at least once. Comfort with Python and some prior experience calling an LLM API is enough; you do not need a background in information retrieval, vector databases, or knowledge graphs, because the course builds those up as it goes. It is probably not the right course if you are looking for a conceptual overview without writing code, since roughly half of the value sits in the assignments. What you will learn ## The seven lessons 1. 01Introduction to Agentic AI & the Memory Problem [Language models](https://www.maximem.ai/glossary/llm) are stateless by default, and that single property produces a surprisingly long list of downstream failures. This lesson maps them, covers what a [context window](https://www.maximem.ai/glossary/context-window) really is and where it breaks, and prices out the habit of replaying full conversation history on every turn. You will take a working chatbot apart and catalogue every point at which it forgets something it should have known, then name the kind of memory that would have prevented each one. [Why a bigger context window is not a memory](https://www.maximem.ai/memory-vs-context-windows) 2. 02The Anatomy of Agent Memory Memory is not one thing. Working memory, [long-term memory](https://www.maximem.ai/glossary/long-term-memory), the split between [episodic](https://www.maximem.ai/glossary/episodic-memory-ai) and semantic recall, entity and profile memory, and procedural memory all behave differently and are needed at different moments. Mapped against how human memory works, so the model stays intuitive rather than academic. You will classify real conversation snippets by memory type, then design a memory schema for a use case you care about, whether that is a support agent, a tutor, or a coding assistant. [How agent memory actually works](https://www.maximem.ai/how-agent-memory-works) 3. 03Ingestion & Extraction: From Raw History to Retrievable Knowledge Storing everything raw is the failure mode that hides the longest, because it looks responsible right up until retrieval quality collapses. This lesson covers fact and preference extraction, [chunking](https://www.maximem.ai/glossary/chunking) strategies that survive contact with messy text, a working primer on [embeddings](https://www.maximem.ai/glossary/embeddings), and where summarisation helps and where it silently destroys the detail you needed. You will build an ingestion pipeline that takes a conversation, pulls out structured facts, and writes them into a local [vector store](https://www.maximem.ai/glossary/vector-database) as [embeddings](https://www.maximem.ai/glossary/embeddings). 4. 04Retrieval Fundamentals: AI Memory vs RAG Retrieval sits directly in the hot path of the agent, so it is judged on latency as much as on relevance. [Semantic and vector search](https://www.maximem.ai/glossary/semantic-search), the working mechanics of [retrieval-augmented generation](https://www.maximem.ai/glossary/rag), [relevance ranking](https://www.maximem.ai/glossary/reranking), and the recency versus relevance tradeoff that every memory system has to take a position on. You will implement semantic retrieval over the memories from the previous lesson, tune top-k and similarity thresholds, add a recency boost, and measure how long your retrieval path actually takes. [Memory versus vector RAG](https://www.maximem.ai/memory-vs-vector-rag) 5. 05Beyond Vectors: Structure, Entities & Time The point where pure vector search runs out of road, and where most memory implementations quietly stop being correct. [Knowledge graphs](https://www.maximem.ai/glossary/knowledge-graph), entity resolution and the Acme versus Acme Corp versus "the client" problem, relationships between entities, temporal reasoning, and what to do when a fact you stored six months ago has since been replaced. You will add entity resolution so that several references to the same thing collapse into one record, plus a latest-wins rule for facts that change over time. [How Maximem Synap models this across three stores](https://www.maximem.ai/synap/how-it-works) 6. 06Scoping, Multi-Tenancy & Privacy Memory becomes a security surface the moment more than one customer is on the system. Memory scopes at the user, organisation, application and global level, [permission-aware retrieval](https://www.maximem.ai/glossary/ai-access-control), data isolation between tenants, and the practical handling of personal data and [compliance](https://www.maximem.ai/glossary/compliance) obligations inside a memory layer. You will implement scoped memory that partitions by user and by organisation, then write a test that proves retrieval never crosses a tenant boundary. [Memory privacy and ownership](https://www.maximem.ai/memory-privacy-and-ownership) 7. 07Memory Hygiene & Quality: Forgetting & Evaluation A memory system that only ever grows gets worse, not better. [Decay and deliberate forgetting](https://www.maximem.ai/glossary/context-eviction), deduplication, keeping the store from bloating, improving what gets retained in the first place, and then the part almost everyone skips: measuring whether any of it worked, including how benchmarks such as LongMemEval are constructed and what they do and do not tell you. You will add deduplication and a decay policy, build a small [evaluation set](https://www.maximem.ai/glossary/evals), and score your agent's recall before and after. [Measuring agent memory, and what benchmarks hide](https://www.maximem.ai/measuring-agent-memory) What you walk away with ## By the end A memory-enabled conversational agent that you built yourself, that keeps hold of a user across sessions, that resolves entities, that enforces scope and privacy boundaries, and that forgets on purpose rather than by accident. It is portfolio-ready, and more usefully, it is a working reference implementation you can pull patterns out of the next time you have to do this at work. Alongside the code, a mental model of agent memory that holds up under production pressure, and direct experience with ingestion, retrieval, entity resolution, scoping and evaluation. Advanced reading ## Go deeper The course teaches the discipline. The paper makes the argument: that agent memory is not merely a storage and retrieval problem, but an architecture problem spanning ingestion, resolution, scoping, decay, and evaluation. If the last lesson left you wanting the longer version, start with the write-up and then read the paper itself. [Read the write-up](https://www.maximem.ai/blog/agentic-context-management-paper)[Read the paper on arXiv](https://arxiv.org/abs/2607.21503) ## Who is teaching it GD ### Gaurav Dadhich CEO and co-founder, Maximem He builds Maximem Synap, a memory layer for AI agents, and recorded this course because the discipline it covers is one almost nobody teaches as engineering. [LinkedIn](https://www.linkedin.com/in/gauravdadhich) ## The course is free. It always will be. Scaler hosts it, there is no cost and no gate on the assignments, and it works fine as a weekend if you are willing to actually write the code. [Start the course](https://www.scaler.com/topics/course/agentic-ai/) We build [Synap](https://www.maximem.ai/synap), a memory layer for AI agents, and the course teaches the problem rather than the product; if you finish it and decide you would rather not maintain all of this yourself, that is a reasonable conclusion and you know where to find us. ## Questions ### Do I need to know vector databases or knowledge graphs already? No. Both get built up from scratch inside the course, starting with a local vector store you can run on your laptop. ### Is this tied to a specific framework? No. Everything is written against plain Python and an LLM API, so the patterns port to LangChain, LlamaIndex, CrewAI, the OpenAI Agents SDK, or whatever you are already running. ### How long does it take? Around seventy-five minutes of video across seven lessons. The assignments are what actually take time, and they are worth the time. ### Is there a certificate? Scaler handles enrolment and anything that comes with it; check the course page for the current details. ### Can I use the capstone in my portfolio? Yes, and that was part of the point of designing the final project the way it is designed. ## Keep learning ### Start with the concepts - [The memory problem](https://www.maximem.ai/the-memory-problem) - [How agent memory works](https://www.maximem.ai/how-agent-memory-works) - [Agentic AI](https://www.maximem.ai/glossary/agentic-ai) - [Context engineering](https://www.maximem.ai/glossary/context-engineering) ### Compare approaches - [Memory vs context windows](https://www.maximem.ai/memory-vs-context-windows) - [Memory vs vector RAG](https://www.maximem.ai/memory-vs-vector-rag) - [Build vs buy agent memory](https://www.maximem.ai/build-vs-buy-agent-memory) - [Measuring agent memory](https://www.maximem.ai/measuring-agent-memory) ### Ship it - [Maximem Synap](https://www.maximem.ai/synap) - [How Synap works](https://www.maximem.ai/synap/how-it-works) - [Framework integrations](https://www.maximem.ai/synap/integrations) - [Full glossary](https://www.maximem.ai/glossary) --- Source: [https://www.maximem.ai/learn/ai-agent-memory-course](https://www.maximem.ai/learn/ai-agent-memory-course)