Thesis: the harness is temporary, the model is temporary, the memory is the org. The vault holds the one asset that survives every model swap and every vendor switch.

What it is

Store: memories as raw content plus metadata (provenance, ACLs, expiry). Embeddings are rebuilt from raw content, so the vault is never locked to an embedding model.
Interface: MCP server for reads and writes, plus ingestion pipelines for an org's existing corpus (docs, tickets, chat, code).
Write governance: the actual product. Session-to-memory extraction, dedup, contradiction resolution, decay, review queues, provenance on every entry.

What it is not

Not a harness. Harnesses are each vendor's crown jewels; the vault sits one layer below, where a standard interface (MCP) already exists.
Not hosted memory. The vault lives inside the customer's perimeter.
Not a model. Intelligence is rented; memory is owned.

MVP: a local vault — Claude-style memory over a folder

Local-only, zero dependencies, one file (server.mjs). The store is a plain directory (memory/) of markdown files with MEMORY.md indexes — the same shape Claude Code keeps its own memory in. The server exposes exactly Claude's core memory commands over MCP — view, create, str_replace, insert, delete, rename — sandboxed to the requesting project's slice of that folder. No search engine, no database, no auth: the model maintains the index, checks for duplicates, and decides what to keep, guided by the server's instructions. Files are the source of truth — edit them by hand, grep them, sync the folder with git.

Layout — per-project spaces + a shared org layer

memory/
  MEMORY.md               # vault index: one line per space
  shared/                 # org-wide memory, read-write from every project scope
    MEMORY.md
  <project>/              # one space per project, isolated from the others
    MEMORY.md
    *.md
    skills/<name>/        # whole skill folders scraped into the vault

The scope is carried in the URL: POST /mcp/<project> sandboxes a session to memory/<project>/ plus shared/; bare POST /mcp is the unscoped whole-vault view — the org "gardener" scope for pruning across projects and promoting facts into shared/.

Quickstart

The package is on npm — no clone, no dependencies (Node ≥18):

MEMORY_DIR=~/memory-vault npx memory-vault   # serves the folder at http://localhost:8787 (127.0.0.1 only)

Set MEMORY_DIR to where you want the vault to live — the default is ./memory relative to wherever you ran the command. VAULT_PORT overrides the port. From a clone, npm start does the same thing.

Connect a repo: `npx memory-vault connect`

One command from the repo root wires it up for every harness it finds:

npx -y memory-vault connect        # add --dry-run to preview, --project <name> to override the space name

It starts the server if it's down (store: $MEMORY_DIR, default ~/.memory-vault), then writes both layers each detected harness needs — the MCP registration in its own config format, and the memory ritual in a rules file it actually loads:

Harness	MCP registration	Ritual
Claude Code	`.mcp.json` (always written — the repo-level MCP convention)	`CLAUDE.md` (imports `@AGENTS.md`)
Cursor	`.cursor/mcp.json`	`AGENTS.md`
Codex	`.codex/config.toml` (trusted projects)	`AGENTS.md`
DSH	printed pointer to `dsh-cordis.patch.yml` (profile patch stays manual)	—

Re-running is idempotent — existing entries are left alone, missing ones added. Then restart the session and approve the vault MCP server when prompted; the memory tools appear from the next session on. If the repo already has harness memory to import, see the scraper below.

Or don't do it yourself:

Ask your agent: "Set up memory-vault for this repo — run npx -y memory-vault connect from the repo root and relay its output."

Connect from Claude Code (manual)

Per repo (recorded in the repo's .mcp.json):

claude mcp add --transport http --scope project vault http://localhost:8787/mcp/<project>

Optionally also at user scope for the whole-vault gardener view — the project-scope entry of the same name wins inside a repo:

claude mcp add --transport http --scope user vault http://localhost:8787/mcp

New sessions get the memory tools; the server must be running.

Connect from DeepSeek Harness

DSH loads MCP servers as Cordis plugin instances via @deepseek-ai/dsh-mcp-client. A ready-to-use patch is in dsh-cordis.patch.yml:

# Per-session (workspace-local)
dsh --profile headless --patch ./dsh-cordis.patch.yml "your task"

# Or make it permanent by copying the entry into:
#   ~/.dsh/profiles/headless/cordis.patch.yml
#   ~/.dsh/profiles/web/cordis.patch.yml

The patch connects to the local vault at http://localhost:8787/mcp/memory-vault; tools appear as mcp__vault__view, mcp__vault__create, etc. The server must be running.

Seed a corpus

Copy markdown files into memory/<project>/ (or memory/shared/) — the store is the folder. Give each name: and description: frontmatter and an index line in that space's MEMORY.md (or let the model tidy that up next session).

Cold-start an existing repo (memory scraper)

First time connecting the vault on a repo that already has harness memory? Scrape it in:

node scripts/scrape.mjs <repo-path> [--dry-run]     # writes into memory/<project>/

Per-harness adapters, each stamping its own source (scrape:<adapter>) and origin path:

Adapter	Scrapes
`claude-memory`	`~/.claude/projects/<repo-slug>/memory/*.md` (Claude Code auto-memory)
`claude-instructions`	`CLAUDE.md`, `CLAUDE.local.md`, `.claude/CLAUDE.md`
`claude-skills`	`.claude/skills/` (whole folders, into `skills/<name>/`; add `--include-user-skills` for `~/.claude/skills/`), `.claude/commands/.md`, `.claude/agents/.md`
`codex`	`AGENTS.md`
`cursor`	`.cursorrules`, `.cursor/rules/*`

Everything lands in memory/<project>/ (project = repo dir name, override with --project) and only that project's MEMORY.md is rebuilt. Names are stable, so re-running is an idempotent refresh. --only <a,b> runs a subset of adapters (skills = claude-skills). User-level files (~/.claude/CLAUDE.md, ~/.claude/skills/) are personal, not org memory — opt in with --include-user / --include-user-skills. --dry-run previews without storing; --claude-home overrides ~/.claude (mainly for tests). Adding a harness = adding one adapter block in scripts/scrape.mjs.

Status

MVP above is the read/write pipe. Write governance (extraction, dedup, contradiction handling, review) comes next. See docs/roadmap.md for the path from local MVP to org deployment, and docs/architecture.md for the architecture sketch.