I wrote a system that remembers 1,390 things my AI assistants told me — using symlinks, no cloud

Does your AI do this? Monday you tell Claude Code "don't touch the auth file."

Wednesday it modifies the auth file. Tuesday you tell Cursor "this project uses
PostgreSQL." Thursday Copilot assumes MySQL.

Three AI assistants. Three separate memories. None of them know what the others know.

This is the most common complaint from anyone using AI coding tools in 2026. And it
hasn't been solved.

The biggest thread on this topic proves the pain is real

Last December, someone posted "Stop Claude Code from forgetting everything" on
Hacker News. It got 202 points and 225 comments. The top comment: "I absolutely
love this concept! It's like the thing that I've been looking for my whole life."

That solution (ensue-skill) is a Shell script for Claude Code only. It can't share
memory across clients. Claude's memory doesn't flow to Cursor. Codex can't read what
Windsurf learned.

My approach: use the OS's oldest capability

I didn't invent a new storage format, a new vector database, or a new embedding model.

I used symlinks.

~/.workbuddy/MEMORY.md     → junction → ~/.agents/memory/MEMORY.md
~/.workbuddy-ai/MEMORY.md  → symlink  → same file
~/.codex/AGENTS.md         → symlink  → same file

Three clients, three different MCP config formats, three different memory injection
methods. But their memory files are literally the same file at the filesystem level.
No sync logic. No API calls. No network requests. Write something in one client, and
every other client sees it immediately.

"The symlink is the deploy step." Deployment is building a file pointer.

But sharing was the easy part

The hard problems surfaced after sharing worked:

Who wrote this? Five clients writing to one SQLite file — attribution was chaos.
→ Mandatory --source tagging. The MCP server auto-detects the calling client from
the parent process name (WorkBuddy.exe → workbuddy, CodeBuddy.exe → codebuddy).

How do I trace corrections? → Bi-temporal tracking. valid_from/valid_to for
when the fact is true in the real world, recorded_at/invalidated_at for when the
system learned it. Supersession never deletes — it builds a pointer chain. You can
ask "what did the system believe X was last Wednesday?" and get an accurate answer.

Concurrent writes? → Built hubguard: msvcrt.locking cross-process mutex,
temp-file + os.replace atomic writes (handling symlinks, hardlinks, and Windows
file locking — three separate bugs), SQLite WAL mode for concurrent readers.

How do you find things? → Four-way retrieval (FTS5 BM25 + keyword IDF +
bge-m3 vectors + ASCII exact match) → Reciprocal Rank Fusion → bge-reranker
→ temporal decay → Q-Value weighting.

What if it's not in the database? → Refusal gate. When keyword coverage and
vector similarity both fall below thresholds, it returns "no relevant information
found" instead of letting the LLM hallucinate. This is the design I'm most proud of:
a memory system brave enough to say "I don't know."

A bug that humbled me

After 22 releases, I ran a security audit and typed one command: PRAGMA journal_mode.
It returned delete.

My README had said "SQLite WAL mode" since version 0.1.0a1. Twenty-two releases,
never enabled. One line of code fixed it. But the lesson stuck: you need a system
that's willing to say "I might be wrong."

Now I have a scoring card called hub_score with a built-in warning: "The evaluator
itself is the object being evaluated. If the score is high, suspect the test."

Real numbers after 19 days of production use

Not a demo. I use this every single day:

• 1,390 memories shared by 5 AI clients through one physical SQLite file
• Every memory carries source attribution, bi-temporal tracking, supersession chain
• 62.6% strict / 55.7% judge / 75.7% EAF on LongMemEval 500Q (our own harness, disclosed failure modes)
• Refusal benchmark: 22 negative samples, 41% intercepted, zero false refusals
• 39 automated tests, CI green, self-check 11/11

If you want your AI to remember what you said

pip install memtether
memtether init    # auto-detects your AI clients and writes MCP configs

23 client adapters. One SQLite file. No cloud. No subscription. Apache-2.0.

GitHub: MemTether/MemTether

---

If you're also working on agent memory, multi-client AI tooling, or local-first
infrastructure, I'd genuinely love to compare notes — hit me up or open an issue on
the repo.

---

Update (October 2026)

MemTether has grown significantly since I wrote this post:

• 567 tests passing (up from 39 at initial submission)
• 9 MCP tools including correct_memory, retire_memory, pin_memory, as_of_query, and timeline — agents can now govern memory, not just search
• proj_judge score: 96/100 (governance tests 11→27)
• Published on PyPI, GitHub Releases, and MCP Registry
• Predicate extraction quality: prose-junk entities 56%→0%, multi-word entities fixed
• Dynamic rebuild quota: max(static_base, 5% of type count)
• External hash-chain anchors for tamper-evidence beyond the local DB

Install: pip install memtether

GitHub: MemTether/MemTether