Your agents keep their brain.

Uteke is agent memory that runs on your infrastructure. Swap your base URL and key. Nothing else about your stack changes.

Private beta. One email at launch, nothing else.

static binary, zero dependencies

2 env vars

is the whole integration

cloud calls in the recall path

768-dim

local embeddings, no API key

Memvid for your laptop. Uteke for your infrastructure.

The open-source core is a single binary your agents talk to over MCP. Uteke cloud runs that core for you: same API, fully managed. No telemetry, by design.

Two env vars. That is the whole migration.

agent config

UTEKE_BASE_URL=https://mem.yourco.dev
UTEKE_API_KEY=utk_live_…
# point it back at your box to leave

★ star the open-source core

Three moves. One API.

The managed API is the same contract as the open-source core: plain JSON over HTTPS. The open-source docs describe every field.

remember

POST /remember
{ "content":
  "Payments need idempotency keys",
  "tags": ["backend"] }

Written once. Embedded and indexed on arrival.

recall

POST /recall
{ "query":
  "how do we avoid double charges?",
  "limit": 5 }

Keyword, vector, and rank votes fuse into one ordering. No mode to pick.

consolidate

on schedule
duplicates merge
stale rows decay
contradictions surface

Memory stays small and current without a cleanup ritual.

Three ways to run it.

Same engine, same API, same export. Pick your trade-offs. Switch when they change.

binary

Your laptop. Air-gapped boxes. One file, gone with one rm.

zero dependencies, zero API keys
fully offline, recall on-device
free forever, no account

you are the admin: updates, backups, uptime

get the binary →

docker

A box you already run. One container, an API key, done.

self-hosted without the setup ritual
same API key and rooms as the binary
updates are one docker pull

domain, backups, monitoring stay on you

run it in docker →

cloud

For builders who would rather ship. We run the core, you keep the keys.

zero ops, always the latest build
workspaces, API keys, hard quotas
NDJSON export keeps the exit open

14-day trial at launch, then paid

join_waitlist →

Eight things you stop operating.

Embedding pipeline: 768-dim EmbeddingGemma runs on CPU. No model server, no embedding API key.
Vector index: Fully managed for you. No Qdrant, pgvector, or Pinecone to provision.
Hybrid rerank: Three scoring signals fuse per query. You never tune retrieval modes.
Tenant isolation: Postgres row-level security on every query, per workspace.
Key auth: Show-once API keys, peppered hashing, rotation windows.
Usage quota: Hard limits that fail closed, metered per workspace.
Portability: NDJSON export of everything, byte-faithful, any time.
Audit trail: Append-only records of writes and access. Boring on purpose.

What managed adds

Zero config: 2 env vars; no SDK, no sidecar, no vendor container in your stack
Agent agnostic: every MCP client; one memory behind every agent you run, present and future
Exit freedom: NDJSON export; your memory leaves with you, in one command, byte-faithful
Privacy default: telemetry off; no telemetry, no third-party analytics on the memory path