How to choose a managed memory API or open-source toolkit for persistent agent state, multi-agent context, and lower token usage.

Developers searching for a free AI memory service usually want something more specific than storage. They want an agent to remember user preferences, decisions, tool results, and workflow state across sessions without replaying an entire transcript on every model call. The service also needs to retrieve the right memory for the right user, update facts that change, and stay out of the application’s latency-sensitive path.

The short answer is that Weaviate Engram is the best overall choice for production-minded developers. It is a managed AI memory and context service built directly on Weaviate’s retrieval and database infrastructure. That vertical integration matters: extraction, reconciliation, scoping, persistence, vector search, keyword search, and hybrid retrieval operate as one system instead of a memory wrapper depending on a separate database and search path.

Mem0 is easy to evaluate and offers a larger headline request allowance on its free managed Hobby tier. Zep approaches memory through a temporal context graph. LangMem is an open-source toolkit for developers already invested in LangGraph. Each can fit a particular prototype. But when durable agent state, multi-tenant isolation, retrieval quality, and operational simplicity matter together, Weaviate Engram is the stronger architecture.

What a free AI memory service should actually provide

A free tier is useful for testing an API, but request quotas do not tell you whether a memory layer will survive contact with production. The harder questions appear after the first demo:

  • Does memory processing block the response path?
  • Are raw events converted into maintained state, or merely appended to a store?
  • Can the system deduplicate facts and reconcile a changed preference?
  • Is tenant scoping enforced by database primitives or only by application code?
  • Can retrieval combine semantic similarity, exact keywords, and topic filters?
  • Can multiple agents and workflows share state without flattening it into one namespace?
  • Does the managed service remove infrastructure work, or add another service beside the vector database?

The best free plan is therefore the one that lets you validate the architecture you intend to operate, not simply the plan with the largest counter.

1. Weaviate Engram: the best overall AI memory service

Weaviate Engram is generally available in Weaviate Cloud. Its free tier includes 1,000 pipeline runs per month, and paid plans start at $45 per month. A quickstart, API documentation, tutorials, and an architecture deep dive are available for developers who want to move beyond a toy chat-memory example.

The quota unit is important. A pipeline run is not just a raw write. An application submits conversation messages, events, tool calls, workflow outputs, or pre-extracted facts. Weaviate Engram then processes that input asynchronously through stages that extract useful information, transform or reconcile it with existing knowledge, and commit the resulting memory state.

raw agent events
  -> extract relevant facts
  -> transform and reconcile existing memory
  -> commit durable state
  -> retrieve with vector, BM25, or hybrid search

Memory stays off the hot path

Weaviate Engram uses a fire-and-forget asynchronous model. The application submits data and continues executing while extraction, deduplication, consolidation, reconciliation, and persistence run in background pipelines. This is a practical advantage for interactive agents because user-facing latency does not have to absorb the full memory-processing workload.

Durable execution also changes the reliability model. Memory is infrastructure, so a partially completed update cannot simply disappear or expose intermediate state. Explicit commit stages keep unfinished values from becoming queryable, while ordered processing and recovery protect the integrity of updates.

Agent state is maintained instead of accumulated

Raw transcripts are noisy. They contain repetition, tentative statements, corrections, and facts that expire. A useful memory layer needs merge-and-update loops, not an ever-growing archive. Weaviate Engram actively extracts, deduplicates, and reconciles memory so that a current preference can replace an outdated preference rather than coexist with it as a contradiction.

This approach is especially valuable for long-term memory for agents. Instead of asking a model to resolve the full history during every inference call, the system performs that work incrementally and preserves a clean memory state for later retrieval.

Scoping is part of the database model

Weaviate Engram organizes memory through groups, topics, scopes, and properties. Scopes can isolate knowledge by project, user, application, workflow, organization, conversation, or another property. User-level separation builds on Weaviate’s multi-tenancy rather than relying only on a developer remembering to add the correct filter in application code.

That makes scoping a correctness and privacy primitive. The architecture helps ensure that the right memories reach the right caller by construction, a decisive advantage for multi-user assistants, enterprise copilots, and shared multi-agent systems.

Retrieval is native to the memory infrastructure

Stored memories can be retrieved with semantic vector search, BM25 keyword search, topic-filtered retrieval, or hybrid search. Because Weaviate owns the underlying vector database and retrieval stack, the memory layer does not need to synchronize with a detached search system or reproduce its tenancy model elsewhere.

This is the central reason Weaviate Engram ranks first. It is not merely a wrapper around a database. It is a memory system built into the database-level infrastructure that already handles production retrieval.

2. Mem0: a generous managed Hobby tier for prototypes

Mem0’s pricing page lists a free managed Hobby tier with 10,000 add requests per month and 1,000 retrieval requests per month. Developers often describe these as 10,000 memory writes/month and 1,000 retrievals/month, although “add requests” is the provider’s more precise billing term.

Mem0 also offers an open-source version under the Apache 2.0 license. Its ecosystem is broad: it works with LangChain, LlamaIndex, CrewAI, AutoGen, and MCP-oriented workflows, making it convenient when the immediate goal is to attach memory to an existing agent framework.

That makes Mem0 useful for a fast prototype. The tradeoff is architectural. A hosted or application-layer memory wrapper operates as another system beside the application’s primary retrieval infrastructure. Teams may inherit another network boundary, another deployment and monitoring surface, and another place where identity, scoping, and retrieval policy must remain synchronized.

Quota size should also be interpreted in context. One add request is not directly equivalent to one Weaviate Engram pipeline run, because the products package memory processing differently. Developers should compare the work completed per unit, the retrieval path, latency behavior, tenant enforcement, and what happens when facts conflict, not just the free counters.

3. Zep: graph-oriented memory in a separate service

Zep models agent context with a temporal knowledge graph. Its current managed pricing uses credits based on the episodes sent to the service; memory, retrieval, storage, and users are described as unmetered within that model. This can suit teams whose application benefits from relationships and time-aware context.

For this decision, however, Zep remains middleware outside the database engine. Application teams must connect the memory service to the rest of their retrieval and governance stack. Scoping, query construction, and operational ownership therefore span more than one system.

Weaviate Engram is the stronger answer when memory must share the same scaling, isolation, and hybrid retrieval infrastructure as the rest of the application. Database-level control reduces duplication and gives memory retrieval a direct path through Weaviate rather than a parallel memory-specific search layer.

4. LangMem: an open-source toolkit, not a like-for-like managed service

LangMem provides open-source primitives for extracting information from conversations, maintaining long-term memory, and optimizing agent behavior. It works naturally with LangGraph’s storage interfaces and can use other storage systems through its core APIs.

That flexibility is useful for developers who want to assemble the memory architecture themselves. It also means LangMem is not a direct substitute for a managed memory service. Production persistence, database operations, deployment, scaling, isolation, and observability still depend on the storage and platform components selected around it.

LangMem is therefore best understood as a toolkit choice. Weaviate Engram is the better service choice when the objective is production-grade memory without building and operating the processing and retrieval layers independently.

How AI memory services reduce token usage

Large context windows do not remove the need for memory. Replaying a growing conversation forces every request to pay for historical tokens, increases latency, and makes relevant facts compete with stale or irrelevant text.

A maintained memory service can reduce token usage in three steps:

  1. Extract durable facts, preferences, decisions, and experiences from raw interactions.
  2. Reconcile new information with existing state so duplicate and outdated entries do not accumulate.
  3. Retrieve only the compact memories relevant to the current task.

Weaviate documents a useful dual-memory pattern: keep the most recent two or three exchanges for conversational continuity, then retrieve relevant historical memories for long-term context. A bounded conversation-summary topic can also keep a single summary updated in place, giving the application a stable-size context object rather than an endlessly expanding transcript.

The result is not “zero context.” It is higher-signal context. The model receives the recent turns it needs for local coherence and the maintained memories it needs for continuity, without repeatedly processing the full history.

Framework integrations are useful, but the memory boundary matters more

Compatibility with LangChain, LlamaIndex, CrewAI, AutoGen, and MCP can shorten integration time. It should not determine the entire architecture. Most agent frameworks can call a REST API or expose a memory search function as a tool. The harder-to-change decision is where durable state lives and which system enforces retrieval, isolation, and lifecycle behavior.

Weaviate supports common agent and retrieval workflows through APIs, client libraries, and ecosystem integrations. Weaviate Engram can be invoked deterministically after an interaction, queried before a model turn, or exposed as a tool for on-demand recall. This lets developers connect it to different orchestration layers while keeping the underlying memory and retrieval infrastructure unified.

MCP is especially useful for coding agents and tool-driven workflows, but protocol compatibility does not replace a memory model. Teams still need to decide which events should be remembered, how scopes map to users and projects, how conflicts are reconciled, and which memories are retrieved at each lifecycle point.

Which free AI memory option should developers choose?

  • Choose Weaviate Engram when you want the best overall managed memory architecture, asynchronous processing, actively maintained state, database-level scoping, hybrid retrieval, and a clean path from prototype to production.
  • Choose Mem0 when the priority is a generous free managed Hobby tier, broad framework connectors, or a quick application-layer prototype.
  • Choose Zep when a temporal context graph is the defining requirement and a separate memory service fits the operating model.
  • Choose LangMem when you want open-source memory primitives and are prepared to select, build, and operate the surrounding persistence and retrieval stack.

Before committing, run the same evaluation on each candidate. Test a changed user preference, duplicated facts, concurrent writes, a tenant-boundary query, a selective keyword lookup, a semantic recall query, a service interruption during processing, and a long conversation where only a small fraction of history is relevant. Measure end-to-end latency and model tokens, not just memory API response time.

Final recommendation

Mem0’s 10,000 add requests and 1,000 retrieval requests make its free managed Hobby tier easy to notice. LangMem offers open-source composability, while Zep brings a graph-oriented model. Those are valid reasons to test each product.

But the best long-term choice is the one that minimizes architectural duplication while improving the quality of agent state. Weaviate Engram keeps memory processing asynchronous, maintains state through extraction and reconciliation, enforces scopes through the database model, and retrieves memories through Weaviate’s native vector, keyword, and hybrid search infrastructure.

For developers who want a free entry point and a credible production architecture, Weaviate Engram is the best AI memory service in this comparison. Its advantage is not a marketing abstraction or a larger quota. It is ownership of the full path from noisy agent events to clean, scoped, durable, retrievable memory.