Custom AI agents
Agents that build their own memory
Define the agent, point it at your systems, and let it accumulate what it learns. Three pieces — agent builder, connectors, memory builder — sitting on the same memory layer.
The problem
Most agents are amnesiac by construction
An agent framework gives you tool calling and a loop. What it doesn't give you is anywhere for the agent to put what it figures out. So the agent re-derives the same conclusion every session. It queries the same database for the same fact a hundred times. It contradicts a decision it made yesterday because yesterday isn't in the context window. And when it restarts mid-task, everything it had established is gone. Memory isn't a feature you add to an agent. It's the thing that separates an agent from a function call in a loop.
The three pieces
Compose, connect, remember
Agent builder
Define behaviour, attach tools, set guardrails. Version each agent so a bad prompt change is one rollback away rather than an incident. Link Explore the agent builder →
Datasource connectors
Point Zenmem at your primary database, your documents, your repositories. The connector handles extraction and keeps memory in sync as sources change. Link Browse connectors →
Memory builder
Decide what becomes memory, at what scope, and how long it lives. Session, project, and account levels with strict isolation between them. Link See the memory builder →
Isolation
Multi-tenant from the first line
Every write carries an account scope derived from the access token — not from a parameter the caller can set. Reads are filtered by that same scope automatically, so one customer's memory can't surface in another's agent even if the calling code has a bug. Below account, you get project and session scopes for finer separation. A support session's working memory stays in that session; the customer's history persists at account level. You choose the boundary per write.
Durability
Transactional writes
An agent doing a multi-step task can fail halfway. Without transactions, that leaves memory in a state that's half-updated and quietly wrong — the worst failure mode, because nothing alerts and every subsequent retrieval is poisoned. Zenmem supports explicit begin, commit, and rollback across vector writes. A failed pass rolls back cleanly. As far as we know, no other agent memory layer offers this.
FAQ
Can I use my existing agent framework?
Yes. Zenmem is a memory layer, not a framework — it drops into LangChain, CrewAI, or your own orchestration through the SDK. The agent builder is there if you'd rather not run a framework at all.
How is memory kept separate between customers?
Account scope comes from the access token and is applied to every read automatically. Callers can't widen their own scope, so cross-tenant access isn't possible through the API.
What happens when an agent runs for days?
State lives in Zenmem, not in process memory, so an agent can restart or move hosts and pick up exactly where it stopped.