Titen

Agent memory that runs with no API key, no LLM, and no embedding provider.
Every memory keeps its source, who may read it, and the evidence that contradicts it.

Website · Documentation · npm · Changelog

Built with C.A.D.I.S Agent.

Try it in 30 seconds

No account, no key, no configuration — but the CLI runs on Bun 1.2 or newer, and refuses to start without it:

curl -fsSL https://bun.sh/install | bash   # skip if you already have Bun
npx titen-memory mcp

With no environment set, that opens or creates ~/.titen/memory.db, writes a real organization, workspace, project and owner into it, and serves MCP over stdio in-process — no HTTP hop, no key to paste, and no outbound network call. Retrieval is FTS5, so nothing needs an embedding provider or a model.

curl -fsSL https://titen.dev/install.sh | bash does the same in one step: it adds Bun when it is missing, then installs the titen command.

Point an agent at it:

claude mcp add --transport stdio --scope user titen -- npx -y titen-memory mcp

Already using @modelcontextprotocol/server-memory? Titen serves the same nine tool names with the same schemas, and answers memory://knowledge-graph too, so a client does not notice the swap. On the first local-mode start it imports your existing graph. Pass the old store's path, because that server writes beside its own install rather than in the directory you launch it from:

claude mcp add --transport stdio --scope user titen \
  --env MEMORY_FILE_PATH=/path/to/memory.jsonl -- npx -y titen-memory mcp

Without it Titen still checks the working directory, its node_modules, and npm's npx cache — and says on stderr when it found nothing, rather than starting empty in silence. Point titen at a served instance later by setting TITEN_MCP_URL and TITEN_API_KEY — full setup below.

Audit what any agent memory store has accumulated, including one Titen does not own:

npx titen-memory audit ./memory.json

What is different about it

• No provider, no key, no account. FTS5 lexical retrieval is the default operating point, not a fallback. Embeddings and model enrichment are opt-in projections that degrade cleanly when they are absent.
• No runtime dependencies. package.json declares none. What it needs is Bun and one SQLite file; everything else is the standard library and Web APIs.
• Drop-in for @modelcontextprotocol/server-memory. Eighteen tools — the nine titen_* plus the nine reference-server names — with search_nodes routed through real retrieval rather than a substring scan, and your existing memory.json imported on first run.
• It audits stores it does not own. titen audit reads a reference-server memory.json, a Mem0 export, or a Titen store, and reports duplicates, recall loops, secret patterns and staleness with per-item evidence you can check by hand.
• The benchmark publishes the losses. Two of the five pre-registered falsifiers fired against Titen, and they are printed on the chart below rather than left out of it.

Already running @modelcontextprotocol/server-memory?

That server had 106,662 downloads in the week of 31 July 2026 — it is the default memory for a large part of the MCP ecosystem, and it is deliberately minimal. Reading its published 2026.7.4 tarball: the store is one newline-delimited JSON file rewritten in full on every mutation, and a search is

graph.entities.filter(e => e.name.toLowerCase().includes(query.toLowerCase()) || ...)

String.includes on a lowercased needle. No tokenizer, no stemming, no ranking — results arrive in insertion order — no scoping or authorization, and no eviction, so the file grows without bound and every call is O(n) in the whole graph. Ask it "which service handles refunds" and it matches nothing unless that exact sentence is stored.

Titen answers the same nine tool names, with the same argument schemas, and the same memory://knowledge-graph resource, so a client does not notice the swap. What changes is underneath: search_nodes runs the real retrieval path — FTS5 with stemming, ranked best-first, and the vector index when one is configured — and every read is scoped to a subject and filtered by authorization before it is retrieved, not after.

Import is on first start; the switch is above.

Audit any agent memory store

Every published memory benchmark measures retrieval on a corpus somebody curated. The failure people actually report is on the write side: a store fills with copies of its own output. The one public audit of a production store found 97.8% of 10,134 entries were junk after 32 days. Nothing measures that.

npx titen-memory audit ~/.titen/memory.db        # a Titen store
npx titen-memory audit ./memory.jsonl            # @modelcontextprotocol/server-memory
npx titen-memory audit ./mem0-export.json --json # a Mem0 export

Five counts — exact duplicate, near duplicate, recall loop, secret pattern, stale — each with per-item evidence you can check by hand. No network, no model, no upload: it opens the path read-only and prints a report; sharing it is your decision. A store that lacks the signal a metric needs is reported as not measurable from this export, never as a failure. There is no composite score and there is no leaderboard.

The detection rules are published in audit rules. Titen's own numbers — including 17.9% duplicates and 96.7% stale in its own store, and a compatibility-surface defect the tool found in Titen itself — are in the self-report.

You author the claims

Titen's default memory model is caller-authored claims. consolidate() takes statements you wrote, each explicitly linked to a source observation you already recorded. Titen does not read a transcript and decide on its own what is worth remembering.

That is deliberate. Every claim has an author, a source, and a scope, which is what makes provenance, permission, conflict, and audit answerable at all. It is also a real cost, and it is the honest comparison point: systems that derive memory from raw dialogue do work Titen hands back to you.

Model-assisted derivation and reflection are implemented and ship in the package, but they are activation-gated and no candidate model has passed the gate — the best result on record is 65.56% against a 90% contract threshold. Treat them as unfinished work with a public gate, not as a feature you can simply switch on. The roadmap carries the current evidence.

The questions Titen answers