Link

Link

Local memory for AI agents.

Link gives Codex, Claude, Cursor, Kiro, VS Code, Copilot, Antigravity, and other local agents the same source-backed memory, stored locally as Markdown.

Website · How it works · Memory · Tools & CLI · Setup · Docs · MCP Registry · PyPI · Homebrew

Quick start

brew install gowtham0992/link/link   # or: pip install link-mcp

lnk setup # wires every agent you have

Then work normally. Tell an agent "remember that we deploy on Tuesdays", approve it once, and every other agent recalls it in a new session tomorrow.

lnk status                                   # is it wired up and being used?

lnk import claude-code # bring existing memory in brew install --cask gowtham0992/link/linkbar # macOS menu bar app

Memory lives in plain Markdown you can open, and nothing becomes durable without your approval.

What Is Link?

Link is an open-source memory layer for local AI agents. Raw sources become an inspectable Markdown wiki. Explicit "remember this" requests become reviewable memories. Agents retrieve compact, source-backed context through the CLI, MCP, official skills, or the local viewer without dumping the whole wiki into a chat window.

The wiki is the storage layer. The product is durable memory that stays on your machine, remains readable in plain files, and can be shared across multiple agents instead of locked inside one vendor profile.

Ask in your own words; Link matches by meaning, not keywords. All local, all plain files.

How It Works

Link gives agents five simple moves:

1. Capture notes, transcripts, docs, screenshots, and project context in raw/.
2. Structure source-backed pages under wiki/.
3. Remember explicit preferences, decisions, facts, and project context as reviewable memory.
4. Retrieve compact query packets through the CLI, MCP, official skills, or the local web viewer.
5. Hold what you approved: rules are enforced before a tool call, memories about code are checked against the repository, and a receipt shows what each session was given.

Most agent sessions start from zero. You re-explain preferences, repo decisions, project constraints, and why something matters. Link turns that repeated context into local memory agents can query.

Link follows Andrej Karpathy's LLM Wiki pattern: keep knowledge outside the chat window, make claims inspectable, and let context compound over time.

Why Link Is Different

Every other agent-memory system stores memory as embeddings in a vector database or as an LLM-extracted graph. Link made five architectural commitments those designs cannot bolt on:

1. Memory you can read. Every memory is a plain Markdown file — open it, grep it, git-diff it. If Link disappeared tomorrow, your memory is still yours.
2. Review-gated writes. Agents propose; you approve. Even the automatic session hooks capture proposals, never facts.
3. No LLM in the memory layer. Ingestion and recall are deterministic — nothing can hallucinate a fact into your memory, because there is no model in the write path.
4. Provably local. CI blocks outbound network code in the runtime, and the optional semantic models load offline-only after one explicit setup.
5. Memory that holds when the agent acts. A memory you reviewed can carry a rule (ask command: git push --force, deny write: migrations/**) that is checked before the agent's tool call, with no model and under a millisecond. Memories about code are re-read against your repository and flagged when the code moved on. Memories surface when the agent opens the file they describe, lnk compile writes reviewed memory into the files every agent already reads, and a receipt proves what reached each session.

And the claims are measured, not asserted — see the benchmarks below. Named comparisons against Mem0/OpenMemory, Zep/Graphiti, and Letta: Why Link?

Benchmarks

Plain files with no LLM in the memory layer, measured against the systems that have one everywhere:

Every number ships with its config, judge model, caveats, and the experiments that *lost* — including LongMemEval end-to-end, where we re-judged both sides under the neutral Hunyuan 3 referee: mem0's GPT-5 answers score 91.0%, Link's budget-model answers 80.6%. Their published number holds up, and the gap tracks the answering model, not the memory layer — that's what the 99.4% evidence-retrieval row above isolates. Full methodology and reproduction steps: benchmarks/RESULTS.md.

Memory You Can Take Anywhere — And Prove Is Working

Three questions every memory system should answer, and how Link answers them with mechanisms instead of promises:

"Is it on all my machines?" lnk sync moves reviewed memory through a git remote *you* control — a private GitHub repo, a homelab bare repo — with no server and no account. Secrets are scanned before anything leaves, conflicts become review items instead of git markers, and private captures never sync. lnk team-sync runs a shared team brain on the same rails.

"What did I believe back then?" Ask in plain language: lnk recall "where does local data live in March" returns what was true *then*, reconstructed from the dated files and their supersede lineage — while the same question without the date returns today's truth. Deterministic: a regex and a calendar, no model. Point-in-time accuracy from plain language: 1.00 on the hygiene benchmark's revised facts, identical to asking with an ISO date.

"Is my agent actually using this?" The question most memory systems cannot answer about themselves. Link records retrievals locally — session briefs pushed to agents, recalls they chose to make — and lnk wins answers with counts, while lnk digest reports the weekly story including memories that have *never* been retriev