Long-term memory for every agent, at the price of its bytes.
Give each agent, user or task its own namespace, made by its first write. Recall by exact text, regex, metadata or vectors in under a millisecond when warm. A memory nobody is using costs only what it stores in S3.
From recorded runs, with how each was measured, on the benchmarks page.
A namespace per agent, user or task
The first write makes it; nothing to provision. Unlimited namespaces on pro. An idle one is a few hundred bytes in object storage and no compute, so a million sleeping memories cost what they store.
Recall that doesn’t guess
Literal and regex search never misses a match on a name, an order number or a stack trace. Add embeddings when meaning matters: vector search narrowed by text and metadata runs in the same query, on the same copy.
Durable before it answers
A write is acknowledged only once it is in object storage, and searchable about 33 ms after. A crashed server loses nothing an agent was told was saved.
Remember, then recall
Memories are documents: an id, text, metadata, and an embedding if you have one. Writing an id again replaces it, so an agent can correct what it knows.
MEM=https://api.skimmerdb.com/v1/namespaces/mem-user-4812 # made by the first write # remember: an id, the text, metadata to filter on, an embedding (optional) curl $MEM/docs -H "Authorization: Bearer $KEY" -d '{ "docs": [{"id": "pref-editor", "text": "Prefers Neovim; dislikes auto-format on save", "meta": {"kind": "preference", "session": 31, "confidence": 0.9}}]}' # writing the same id again replaces the memory; forget by id curl $MEM/delete -H "Authorization: Bearer $KEY" -d '{"ids": ["pref-old"]}'
# exact recall: names, ids, error codes never get "close enough" curl $MEM/search -H "Authorization: Bearer $KEY" -d '{ "q": "neovim", "filter": {"kind": "preference"}}' # by meaning, narrowed by a filter and a word, in one query curl $MEM/search -H "Authorization: Bearer $KEY" -d '{ "vector": [0.12, -0.03, ...], "q": "deploy", "filter": {"session": {"gte": 25}}, "limit": 8}' # the most recent memories (newest first), and exactly how many there are curl $MEM/search -H "Authorization: Bearer $KEY" -d '{"q": "", "limit": 20}' curl $MEM/count -H "Authorization: Bearer $KEY" -d '{"filter": {"kind": "episode"}}'
Agents connect themselves
SkimmerDB is a remote MCP server. The user signs in once with OAuth, picks the namespaces and read or write, and the agent gets tools to search, write, count and run SQL over its memory. Every connection has its own revocable key.
- Scoped. A key or connection can be limited to
mem-agent-7-*; everything else looks like it doesn’t exist. - Capped. Rate, queries and writes a period, per key, so one runaway agent can’t run up the bill.
- Metered. Every answer reports what it cost: warm or cold, object-store reads, CPU.
# Claude Code: the agent gets search, write_documents, count, sql_query... claude mcp add --transport http skimmerdb https://api.skimmerdb.com/mcp # or a key that can only touch its own memories, read and write curl https://api.skimmerdb.com/v1/keys -H "Authorization: Bearer $ADMIN" -d '{ "name": "agent 7", "scope": "write", "namespaces": ["mem-agent-7-*"]}'
Memory patterns
| User memory | One namespace per end user (mem-user-4812). Preferences, facts and past answers, recalled by text, filter or vector. |
| Episodic log | Every turn or tool call as a document with session and kind in metadata. Search lists newest first; a cursor pages back through history. |
| Task scratchpad | A namespace for one task, written as the agent works and dropped when it’s done. Nothing runs for it while it sleeps. |
| Shared team memory | Several agents read one namespace with read-only keys, while one writer curates it. Keys can be limited to a prefix like team-a-*. |
| Memory that analytics can read | The same documents answer SQL: GROUP BY over kinds, sessions or tools, with text predicates. See agent analytics. |
Cachejay, a Mac app that remembers what you’ve seen on screen and said in calls, keeps every account’s library in its own SkimmerDB namespace. ChatGPT and Claude search it through Cachejay’s remote MCP server, from a laptop or a phone.
Questions
What is agent memory?
Long-term memory for an AI agent is what it saved in earlier sessions (facts about a user, preferences, past steps and their results) and can look up later. SkimmerDB stores each agent’s or user’s memory as documents in its own namespace and recalls them by exact text, regex, metadata filters or vector similarity.
Do I need a vector database for agent memory?
Not only one. Embeddings find things that mean the same, but they blur exact tokens such as names, ids, order numbers and error codes. SkimmerDB does both on one copy: exact and regex search with exact counts, and vector search that can be narrowed by text and filters in the same query.
How much does an idle agent’s memory cost?
Only its storage: $0.10 per GB-month on pro, and the free plan includes 1 GB. A namespace nobody is using has no server, cache or process of its own. Its first query after a long sleep reads from object storage in a round trip or two.
How fast is recall?
About 0.8 ms at the median for a warm query on real S3 in our benchmarks, and tens of milliseconds for a namespace read cold from object storage. Every answer reports whether it was warm or cold and how many object-storage reads it made.
Can an agent use it directly?
Yes. SkimmerDB is a remote MCP server with OAuth: Claude, Claude Code, ChatGPT, Cursor and Codex connect to https://api.skimmerdb.com/mcp, and the user picks which namespaces the agent may use and whether it may write. The REST API and Python and TypeScript clients do the same from your own code.
How do I keep one agent or user from reading another’s memory?
Give each its own namespace and a key limited to it (or to a prefix such as mem-user-4812-*), read-only if it only recalls. A namespace outside a key’s reach answers exactly like one that doesn’t exist.
What happens if a server fails mid-write?
Nothing acknowledged is lost: a write is answered only once it is stored in object storage, and servers keep nothing that isn’t also there. A fresh server on an empty disk was serving again in about 0.3 s in our recovery benchmark, with every acknowledged document there.
Give every agent a memory
Free up to 1 GB stored and 100k queries a month. No card to start.