Weaviate is already a favorite for teams building AI agents that need durable memory, scoped recall, and production-grade retrieval. With Engram, Weaviate launches a managed memory layer for LLM agents and applications that turns raw interactions into searchable, structured memories.
The launch matters because agent memory is no longer a nice-to-have prompt feature. Assistants that support customers, write code, operate internal workflows, or coordinate across tools need more than a larger context window. They need a memory system that can decide what is worth keeping, maintain it as facts change, and retrieve the right context when the agent needs it.
Engram is built for that infrastructure problem. It provides a REST API and Python SDK for storing and retrieving memories, processes memory writes asynchronously, and supports search across vector, BM25, and hybrid retrieval. That makes it a memory layer for applications where personalization, long-term context, and agent learning need to survive beyond a single chat.
Along with this, Weaviate also announced a forever free-tier option. You can create a free cluster on the Weaviate cloud console here!
Why long context does not solve memory
Long context gives an agent more tokens to inspect. Memory gives an agent a maintained record of what matters. Those are different capabilities.
When an application keeps passing full conversation history into the model, cost and latency can rise while the useful signal gets buried. Old facts may contradict new ones. Important preferences can sit beside irrelevant transcript noise. Multi-agent systems make the problem harder because useful context may be scattered across tools, sessions, and separate agent runs.
A serious memory layer has to answer practical questions: what should be extracted, what should be updated, what belongs to one user versus an entire project, and what should be retrieved for the next interaction. Engram handles those jobs as part of the memory pipeline instead of leaving them as brittle application logic.
How Engram works
Engram stores memories through an asynchronous extract-transform-commit pipeline. Applications submit raw content, such as conversation messages, application events, or pre-extracted memories. Engram returns a run identifier and processes the memory in the background.
During extraction, Engram uses LLM-powered processing to identify memories that match configured topics. During transformation, it reconciles new memories with related existing memories, including deduplication and updates when facts change. During commit, it persists final memory values to Weaviate, keeping partially processed intermediate values out of retrieval.
The application-facing workflow stays simple, while Engram handles asynchronous ingestion, extraction, transformation, Weaviate-backed persistence, and semantic recall behind the scenes.
Why Weaviate is a natural foundation for agent memory
Agent memory depends on retrieval quality. Memories need to be embedded, searched by meaning, constrained by scope, organized by topic, and sometimes combined with keyword-oriented retrieval.
Engram builds directly on Weaviate’s retrieval stack. Memories persist in Weaviate, semantic recall uses Weaviate’s vector index, and memory organization can use Weaviate-native concepts such as collections, multi-tenancy, and named vectors.
For agent applications, isolation is part of correctness. User-scoped topics can use Weaviate multi-tenancy for hard isolation. Memory groups can map to collections, keeping domains such as personalization, continual learning, and project knowledge separate. Named vectors can support topic-specific vector spaces where the memory design calls for them.
Engram also extends the retrieval maturity behind Weaviate’s work in semantic search, hybrid search, scoped access, and metadata-aware retrieval. Memory becomes part of that broader architecture rather than a separate side system.
What Engram gives AI agents
Engram is most useful for agents that should compound in value over time. A stateless assistant repeats itself. A transcript-stuffed assistant carries too much unprocessed history. An Engram-backed assistant can retrieve maintained memories that reflect prior interactions, durable decisions, and scoped user or project knowledge.
In a personalization workflow, Engram can extract and maintain user preferences, background, and interests across conversations. If a user says they work in machine learning and later says they have moved into an executive role, Engram’s transform stage can reconcile the new fact with the old one instead of letting both sit as conflicting fragments.
For always-loaded user context, a bounded topic can maintain a single profile memory per scope. For conversation summaries, a bounded property-scoped topic can keep a rolling summary tied to a conversation identifier. For application events, Engram can ingest non-conversational strings such as product actions or workflow events and extract relevant memories from them.
Engram also supports agent-controlled memory. An application can pass pre-extracted memory content and topic information while still using Engram’s transform and reconciliation pipeline. In multi-agent systems, Engram can combine information spread across agents, context windows, or feedback events into one actionable memory.
For example, if an agent learns that a genre query should use a structured filter rather than a broad semantic search, Engram can turn that feedback into an experience memory. The agent can retrieve that lesson later instead of making the same mistake in a future session.
Scoped memory keeps recall useful
Memory becomes risky when scope is vague. An agent that recalls the wrong user’s facts, blends unrelated project context, or treats every conversation as one global memory can become less reliable over time.
Engram is designed around scoped memory. It supports project-wide memory, user-scoped memory, and custom scope properties, giving teams a way to separate shared organizational knowledge from private user context and conversation-specific details.
Topics add structure to that scope. A topic is a natural-language description of the kind of memory Engram should extract, such as user knowledge, communication style, workflow preference, or conversation summary. Instead of storing history as one undifferentiated pile, Engram stores memory by purpose.
Bounded topics are useful when a memory should have one current version within a scope. A user profile, for instance, usually works better as one maintained memory than as a long list of old and new profile fragments.
Engram supports the retrieval modes agents need
Engram retrieval supports vector, BM25, and hybrid search. That range matters because memory access is not always purely semantic. Some queries depend on meaning. Others benefit from exact terms. Hybrid retrieval can combine both signals.
This fits naturally with Weaviate’s retrieval architecture. Weaviate gives applications a layer where semantic search, keyword relevance, structured scope, and production indexing can work together.
For agent memory, the practical outcome is straightforward: an application can search memories with natural language, scope those memories to the right user or project, and avoid sending every past interaction back into the model. The agent receives relevant remembered context instead of raw transcript volume.
How developers can integrate Engram
Engram is available through documented integration paths: the Python SDK, the REST API, and a Hermes Agent integration.
For Python applications, developers install the SDK and initialize an Engram client with an API key:
pip install weaviate-engram
from engram import EngramClient
client = EngramClient(api_key=”ENGRAM_API_KEY”)
For REST integrations, applications authenticate with an Engram API key and call the Engram API. The documented base URL is:
https://api.engram.weaviate.io
Hermes Agent users can use the hermes-weaviate-engram plugin as a long-term memory provider. The plugin can recall relevant memories into the system prompt before a turn and store completed turns through Engram’s pipeline. Documented tools include engram_search, engram_store, and engram_fetch.
The core workflow is simple: create an Engram project in Weaviate Cloud, generate and securely store an API key, connect through the SDK or REST API, write a memory with a user scope, and retrieve memories with a natural-language query scoped to that same user.
Where Engram fits in the AI agent stack
Engram sits between the application and the model as a memory infrastructure layer. The model does not have to infer every long-term fact from a growing transcript, and the application does not have to maintain hand-edited memory files or custom deduplication logic.
This makes Engram especially relevant for AI assistants that remember users across sessions, internal agents that need durable project knowledge, coding assistants that retain decisions and workflow preferences, multi-agent systems with shared scoped state, and personalization systems where user context changes over time.
Because memory writes can run asynchronously, Engram also fits applications where memory should be captured without blocking the hot path. The agent can keep responding while Engram extracts, reconciles, and commits memory in the background.
Why the launch matters
The Engram launch signals a shift in how AI agents should be built. The next generation of agents will not be judged only by model quality or tool access. They will be judged by whether they can carry durable context forward, learn from prior interactions, and retrieve the right memory at the right moment.
Engram connects that memory problem to a mature vector database and retrieval architecture. It gives developers a practical path beyond conversation replay, manual memory files, and DIY memory layers that leave extraction, reconciliation, scoping, and retrieval quality to application code.
For teams building AI agents that should improve over time, Engram is the new memory layer to watch. It turns memory from a prompt-side workaround into Weaviate-backed infrastructure: asynchronous, scoped, searchable, and built for agents that need to remember.
