Ask most AI agents the same question twice, a week apart, and you’ll get the same answer twice, because nothing from the first conversation survived it. Context windows hold what’s in front of the model right now. Memory is different: it’s what an agent carries forward on its own, without you repeating yourself.
Some platforms treat that as the whole product. Others bolt it on as a side feature, or skip it entirely. Shogo builds memory into the core SDK rather than selling it as an add-on, and six other platforms take six different approaches. Here’s how each actually handles memory, not just how they describe it.
1. Shogo
What it is: A harness that AI agents use to build and run real software, with a per-user memory layer built into the SDK rather than sold as a separate add-on.
Strengths: Shogo’s memory runs on per-user markdown facts indexed with SQLite FTS5 and in-process TF-IDF, with no vector database to stand up or pay for, and retrieval runs in single-digit milliseconds. An optional LLM summariser de-duplicates facts and resolves conflicts across calls, so the memory store doesn’t just grow with contradictory notes. Shogo’s glossary states that Shogo agents learn from every interaction and improve continuously, holding both short-term context within a conversation and long-term facts across sessions, shipped inside the same SDK as auth and the database rather than a separate integration.
Weaknesses: The markdown-facts-plus-FTS5 approach is built for fast, per-user recall of discrete facts rather than the entity-relationship graphs that a dedicated graph-memory product builds. Memory runs per user inside a Shogo project; it isn’t sold as a standalone API a team can drop into a completely different, non-Shogo stack the way Mem0 or Zep are.
Best for: teams already building on Shogo who want their agents to remember users across sessions without adding, configuring, or paying for a separate memory service.
2. Mem0
What it is: A dedicated memory layer you add to any agent stack, built specifically to store, retrieve, and update facts about users across conversations.
Strengths: Memory is the entire product, not a feature bolted onto something else, and it shows in the depth: Mem0’s own pricing page lists graph memory with entity linking and a “Dream” memory-consolidation feature on its Pro plan, on top of the basic add-and-retrieve API. The Hobby plan is free with 10,000 add requests and 1,000 retrieval requests a month, enough to build and test a real integration before paying anything, and Starter is $19 a month for a small production app.
Weaknesses: Mem0 is infrastructure for a memory layer, not a full agent platform, so it has to be wired into whatever framework or model stack you’re already running rather than working out of the box. Graph memory and consolidation, the features that go beyond basic fact storage, sit behind the $249-a-month Pro plan.
Best for: teams building their own agents on LangChain, a custom stack, or another framework that needs a dedicated, provider-agnostic memory API rather than a full platform.
3. Letta (formerly MemGPT)
What it is: A framework for building stateful agents, grown directly out of the original MemGPT research on giving language models memory beyond their context window.
Strengths: Letta’s agents maintain what the project calls a single perpetual thread, a continuous sequence of messages the agent can manage itself, deciding what to keep in active context and what to page out to long-term storage. Self-hosted Letta is free and includes every feature with nothing held back for the open-source version, and Letta’s own benchmarking work found that a plain filesystem-backed approach scored competitively against purpose-built vector memory systems on the LoCoMo benchmark, a useful reality check on how much complexity memory actually needs.
Weaknesses: Letta is a framework for developers building agents, not a finished product with a chat interface a non-technical team can pick up directly. Letta’s own pricing page puts its managed Pro plan at $20 a month, and notes that heavier coding or computer-use workloads typically land closer to $100 to $200-plus a month in usage, on top of whatever model costs the agent generates.
Best for: engineering teams building a custom agent who want direct control over memory architecture and are comfortable working at the framework level rather than a packaged product.
4. Hermes Agent
What it is: An open-source, self-hosted AI agent from Nous Research built around a learning loop: it creates its own skills from experience and carries memory forward across sessions without a separate memory service bolted on.
Strengths: Persistent memory is core to what makes Hermes Agent distinct, not an add-on: its own site describes memory that deepens over time and a model of who you are that builds across sessions, and it’s free and fully open source under the MIT license. It runs on your own server or hardware, so the memory store never leaves infrastructure you control, and you can point it at your own model provider instead of a hosted one.
Weaknesses: Being self-hosted and terminal-driven means a non-technical team has real setup work before getting a working agent, and official managed hosting is a smaller, newer offering than the open-source core. It’s built as a single personal or small-team agent rather than a multi-tenant platform for a whole organization to build on.
Best for: technical users and small teams who want a genuinely self-improving agent with its own persistent memory, running on hardware they control, without paying a vendor for the privilege.
5. Zep
What it is: An enterprise context platform that unifies conversations, business data, and documents into memory an agent can retrieve, built on Graphiti, Zep’s open-source temporal knowledge graph engine.
Strengths: Zep’s graph-based approach tracks not just what a fact is but when it stopped being true, which matters for agents working with data that changes over time, like a customer’s plan tier or a deal’s stage. Zep’s pricing page shows a Flex plan starting at $125 a month, with usage-based overage, aimed squarely at production use rather than a hobby project.
Weaknesses: There’s no meaningful free tier for real usage, so trying Zep on a live workload means committing to a paid plan from close to day one. Like Mem0, it’s a memory layer you integrate into an existing agent stack rather than a full platform that builds the agent for you.
Best for: enterprises with agents that already pull from multiple internal data sources and need memory that tracks how facts change over time, not just what they currently are.
6. Workato
What it is: An enterprise integration and automation platform that has added agentic capabilities, called Genies, on top of its existing workflow engine.
Strengths: Workato’s reach across enterprise systems is real: it connects deeply into the same SaaS tools (Salesforce, Workday, NetSuite) that large companies already run their operations on, so a Genie can act on live business data without a separate integration project.
Weaknesses: Workato’s own documentation is specific about the limit here: Genies retain context within a session innately, meaning continuity holds for the length of one session, not automatically across sessions the way a dedicated memory layer is designed to. A team that needs an agent to remember a customer’s preferences three weeks later has to build that persistence themselves rather than get it as a platform default.
Best for: enterprise automation teams who need an agent wired deeply into existing business systems and are willing to add their own persistence layer on top for memory that needs to survive past one session.
7. Make
What it is: A visual, no-code automation platform for building workflows (called scenarios) across thousands of connected apps.
Strengths: Make’s Data Store module gives a scenario a simple key-value database it can read from and write to between runs, which is enough to track things like “have we already contacted this lead” across separate scenario executions. It’s flexible and easy to wire into any scenario without writing code.
Weaknesses: A Data Store is a manual database table you design and query yourself, module by module, closer to a spreadsheet the automation reads from than memory the agent manages on its own. Nothing decides what’s worth remembering or retrieves it automatically when it’s relevant; every lookup has to be built into the scenario by hand.
Best for: teams already building in Make who need simple state tracking between workflow runs and don’t need an agent that manages its own memory.
How to choose
The honest split here is between memory as the product and memory as a feature. Mem0, Letta, and Zep exist specifically to solve memory, and they go deep: entity graphs, time-aware facts, consolidation that merges duplicate memories instead of just piling them up. Hermes Agent builds that depth into a single self-hosted agent instead of selling it as infrastructure for someone else’s. Workato and Make represent the other end: memory is either session-bound or something you build by hand with a generic data table, because memory was never the point of the platform.
Shogo sits closer to the first group without asking you to integrate a separate vendor: memory ships in the same SDK as the rest of the platform, retrieval runs in single-digit milliseconds with no vector database to operate, and an agent remembers a user across sessions by default rather than needing that wired in.
If the pricing model behind any of these platforms is the open question instead, we broke down credits, per-seat, and unlimited-usage plans in our guide to AI agent pricing models, and how to avoid getting locked into one model or vendor in our guide to reducing AI agent costs.
FAQ
Does Shogo have persistent memory for AI agents?
Yes. Shogo agents hold per-user memory indexed with SQLite FTS5 and TF-IDF, with retrieval in single-digit milliseconds and no vector database required, and an optional LLM summariser resolves conflicting facts over time. Memory ships as part of the core SDK rather than a separate product to integrate.
What’s the best AI agent platform with long-term memory?
It depends on whether you want memory as a feature of a finished platform or as infrastructure to build on. Shogo and Hermes Agent both build persistent, cross-session memory into the agent itself. Mem0, Letta, and Zep are dedicated memory layers meant to be wired into whatever agent framework or platform you’re already building with.
Is there a free AI agent memory solution?
Yes. Letta’s self-hosted version is free with every feature included, Mem0’s Hobby plan is free with 10,000 add requests a month, and Hermes Agent is free and open source end to end. Shogo’s free plan also includes agent memory, since it’s part of the core platform rather than an upsell.
What’s the difference between context window and memory in AI agents?
A context window is what the model can see in a single request, and it resets or gets truncated as a conversation grows. Memory is a separate system that persists facts outside that window, in a database, so an agent can retrieve exactly what’s relevant to a new conversation instead of needing the entire history re-fed to the model every time.
Can an AI agent forget things on purpose?
Platforms built specifically for memory generally support this. Mem0 and Zep both let you delete or update specific stored facts, and Zep’s temporal graph tracks when a fact stops being true rather than just overwriting it silently. Shogo’s optional LLM summariser resolves conflicting facts over time rather than keeping every contradictory version forever.
Do I need a separate memory service, or does my AI agent platform already have one?
Check whether memory is described as something the agent does automatically across sessions, or something you’d wire up yourself with a generic database or data store. Shogo, Hermes Agent, Mem0, Letta, and Zep all treat cross-session recall as a built-in or purpose-built capability; Make’s Data Store and Workato’s session-only context are manual or session-bound by comparison, and would need extra work to behave like true persistent memory.
