Memory Optimization for Agentic Systems
...explained with code (in LangGraph)!
Learn your API maturity in 5 minutes
70% of internal APIs inside large companies are either undocumented or inconsistently governed.
This means teams ship slower, duplicate work, and hit security gaps long before they ever think about AI readiness.
Postman released a quick API Maturity Assessment that helps you measure where your org stands across six dimensions: impact, discoverability, reuse, quality, governance, security, and AI readiness.
It is a five-minute walkthrough that highlights what your current API practices reveal about business impact, developer experience, and whether your APIs can actually support automated AI systems.
If you want a clear picture of your API health, plus specific steps to close the gaps, this is useful.
You can take the API maturity assessment here →
Thanks to Postman for partnering today!
Memory Optimization for Agentic Systems
We have added Part 15 to our AI Agents crash course, where we use LangGraph to understand how memory works internally and then also implement it inside an Agent from scratch.
But what exactly is Memory, and why is it so powerful for Agentic systems?
To understand this, consider an Agentic system without Memory (below):
In iteration #1, the user mentions their favorite color.
In iteration #2, the Agent knows nothing about iteration #1.
This means the Agent is mostly stateless, and it has no recall abilities.
But now consider an Agentic system built with Memory (below):
In iteration #1, the user mentions their favorite color.
In iteration #2, the Agent can recall iteration #1.
Memory matters because if a memory-less Agentic system is deployed in production, every interaction with that Agent will be a blank slate.
It doesn’t matter if the user told the Agent their name five seconds ago, it’s forgotten. If the Agent helped troubleshoot an issue in the last session, it won’t remember any of it now.
With Memory, your Agent becomes context-aware and practically applicable.
But Memory isn’t an abstract concept.
If you dive deeper, it follows a structured and intuitive architecture with several types of Memory.
Short-Term Memory
Long-Term Memory
Entity Memory
Contextual Memory, and
User Memory
Each serves a unique purpose in helping agents “remember” and utilize past information.
To simulate memory, the system has to manage context explicitly: choosing what to keep, what to discard, and what to retrieve before each new model call.
This is why memory is not a property of the model itself. It is a system design problem.
You can read Part 15 with LangGraph and how to optimize it here →
Also, Part 8 and Part 9 of the crash course cover memory with CrewAI:
Both parts cover:
5 types of Memory from a theoretical, practical, and intuitive perspective.
How each type of Memory helps an Agent.
How an Agent retrieves relevant details from the Memory.
The underlying mechanics of Memory and how it is stored.
How to utilize each type of Memory for Agents (implementations).
How to customize Memory settings.
How to reset the Memory if needed.
And more.
Here’s everything we did in the crash course (with implementation):
In Part 1, we covered the fundamentals of Agentic systems, understanding how AI agents act autonomously to perform tasks.
In Part 2, we extended Agent capabilities by integrating custom tools, using structured outputs, and we also built modular Crews.
In Part 3, we focused on Flows, learning about state management, flow control, and integrating a Crew into a Flow.
In Part 4, we extended these concepts into real-world multi-agent, multi-crew Flow projects.
In Part 5 and Part 6, we moved into advanced techniques that make AI agents more robust, dynamic, and adaptable, like Guardrails, Async execution, Callbacks, Human-in-the-loop, Multimodal Agents, and more.
In Part 8 and Part 9, we primarily focused on 5 types of Memory for AI agents, which help agents “remember” and utilize past information.
In Part 10, we implemented the ReAct pattern from scratch.
In Part 11, we implemented the Planning pattern from scratch.
In Part 12, we implemented the Multi-agent pattern from scratch.
In Part 13 and Part 14, we covered 10 practical steps to improve Agentic systems.
It covers everything in detail to fully equip you with the skills to build agentic systems.
Of course, if you have never worked with LLMs, that’s okay.
We cover everything in a practical and beginner-friendly way.
Thanks for reading!