Per-user retrieval for agents, skimmed off object storage.
Your app writes each customer’s data to its own namespace; your agent searches only theirs, by exact text, regex, filters and vectors. Hot namespaces answer from RAM and NVMe; everything else sits in S3 for the price of their bytes.
curl $NS/search -d '{"q": "acme-1042",
"filter": {"status": "open"}}'{
"hits": [{ "id": "t-1",
"line": "Refund requested for order ACME-1042" }],
"took_ms": 0.41,
"temperature": "warm",
"store_gets": 0
} Skim the surface. Dive only when you must.
Like the bird it's named for, SkimmerDB answers from the surface whenever it can. When a namespace hasn't been touched in a while, it reads only what the query needs from object storage: no servers sit warm for data nobody is asking about.
Memory for every agent
A namespace per agent, user or task, created on the fly. Thousands of them sit idle at the price of their bytes and answer again in a round trip or two.
Agent memory →Support agents and help centers
A namespace per help center. The bot finds the error code a customer pasted exactly, the question they asked by meaning, and nothing from any other company.
Support agents →Copilots inside your SaaS
Each customer’s documents in their own namespace, and a key per customer the copilot searches with. Isolation that doesn’t depend on a tenant_id filter.
Multi-tenant RAG →Code search for coding agents
A namespace per repository or branch. RE2 regex answered from an index and exact counts: every call site, with no checkout.
Coding agents →Analytics on what agents did
SQL with GROUP BY, exact counts and text predicates over traces, tool calls and events, on the same copy they search. Import CSV, NDJSON or Parquet.
Agent analytics →Vectors on the same data
Store an embedding with each document and search by meaning, alone or narrowed by text and filters in the same query. One copy, one bill.
Vector search →One API for every kind of lookup
Every answer says whether the namespace was warm or cold and how many object-storage reads it made, so you always know what a query cost.
NS=https://api.skimmerdb.com/v1/namespaces/support # made by the first write
# upsert: text, metadata, an embedding (optional)
curl $NS/docs -H "Authorization: Bearer $KEY" -d '{
"docs": [{"id": "t-1",
"text": "Refund requested for order ACME-1042",
"meta": {"status": "open", "priority": 3},
"vector": [0.12, -0.03, ...]}]}'# exact text (or "regex": true), filtered, newest first curl $NS/search -H "Authorization: Bearer $KEY" -d '{ "q": "acme-1042", "filter": {"status": "open"}}' # nearest neighbours, narrowed by text and a filter curl $NS/search -H "Authorization: Bearer $KEY" -d '{ "vector": [0.12, -0.03, ...], "q": "refund", "filter": {"priority": {"gte": 2}}, "limit": 10}'
Your backend writes. The agent sees one tenant.
The agent doesn’t have to write anything: sync data from your app with the API, the Python and TypeScript clients or a bulk import. The agent gets a key that reaches one customer’s namespace, so isolation is the database’s job, not your prompt’s or a tenant_id filter’s.
- Scoped keys. Read, write or admin; optionally only some namespaces, like
user-4812oragent-7-*. - Isolation. A namespace outside a key’s reach looks exactly like one that doesn’t exist, over REST and MCP.
- Caps per key. Request rate, queries and writes per billing period.
- MCP with OAuth. Claude, ChatGPT, Cursor and Codex connect themselves; the user picks the namespaces and read or write.
# your backend writes each customer's data to its own namespace curl $B/v1/namespaces/user-4812/docs -H "Authorization: Bearer $ADMIN" \ -d '{"docs": [{"id": "n-1", "text": "Prefers invoices in EUR"}]}' # the agent serving that customer gets a key for theirs alone curl $B/v1/keys -H "Authorization: Bearer $ADMIN" -d '{ "name": "agent for 4812", "scope": "read", "namespaces": ["user-4812"]}' # every other namespace: 404, as if it didn't exist
Your bucket, your files, any cloud.
Data can come from your own bucket and go back to it. Import CSV, NDJSON and Parquet from AWS S3 or any S3-compatible store, keep a DuckLake table in step, and export answers as Parquet that DuckDB, pandas or Spark read as is.
- Any S3-compatible store. AWS S3, Cloudflare R2, Backblaze B2, Wasabi, DigitalOcean Spaces, MinIO.
- Keys never stored. They come with the request and are dropped when it ends.
- DuckLake. Each sync writes only the rows that changed. Search your DuckLake →
- Everything out. Exports as CSV, NDJSON or Parquet, into your bucket. Your bucket →
# files from your own bucket: AWS S3, Cloudflare R2, Backblaze B2, MinIO curl $B/v1/namespaces/events/import/bucket -H "Authorization: Bearer $KEY" -d '{ "path": "s3://events/2026/10/*.parquet", "id": "event_id", "s3": {"endpoint": "https://<account>.r2.cloudflarestorage.com", "region": "auto", "access_key_id": "...", "secret_access_key": "..."}}' # and answers back into it, as Parquet curl $B/v1/sql/exports -H "Authorization: Bearer $KEY" -d '{ "sql": "SELECT * FROM events WHERE status >= 500", "format": "parquet", "destination": {"path": "s3://reports/errors.parquet", "s3": {...}}}'
Fast when warm, cheap when idle
Latency from recorded runs on real S3, and what a month would cost you at today's prices.
Cold queries also pass on their object-storage reads ($0.50 per million reads; a warm query makes none). Idle namespaces cost only their bytes.
Limits
Give every customer their own index
Free up to 1 GB stored and 100k queries a month. No card to start.