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.

Works with Claude CodeClaudeChatGPTCursorCodexany MCP clientREST
$
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
}
Every answer says what it cost

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.

Above the waterlineRAM + NVMe on our servers, for the namespaces your agents are using now
0.8mswarm query p50
0.97vector recall@10
5,600vector queries/s a server
Below the waterlineEvery namespace, every document, in S3. The only full copy: servers are a cache
2round trips for a cold query
~33mswrite to searchable
$0compute for an idle namespace

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.

write
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, ...]}]}'
query
# 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-4812 or agent-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.
one key, one tenant
# 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 →
in and out of 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.

Latency, measured
Workload12k web pages (1.77 GB) + 2k tenants, real S3
p50
0.80ms1.0ms
p90
25ms33ms
p99
64ms131ms
Warm namespaceCold namespace
coldbench: Zipf mix from 8 clients, one c7gd.2xlarge, 400 MB cache, S3 Standard us-east-1; cold = empty disks · all benchmarks
Cost calculator
Storage$0.10 / GB-month
1M docs (~4.6 GB)
$0.46
Writes$0.25 / GB
10% rewritten a month (~407 MB)
$0.10
Queries$0.50 / million
1M queries a month
$0.50
Estimated cost $10.00 monthly minimum, counted against usage
$10.00/month

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

NamespacesUnlimited
Write throughput (one server, measured)50k+ docs/s to S3
Time to searchable (measured)~33 ms
Vector search recall@10 (defaults)0.97
Vector queries / s (one server, measured)5,600
Vector dimensions1 to 2,048
Document text2 MB
Metadata per document16 KB
Documents per write10,000 (64 MB)
Results per query1,000
RegexRE2, linear time

All limits in the docs →

Give every customer their own index

Free up to 1 GB stored and 100k queries a month. No card to start.