Local agent memory

Link gives every agent the same memory.

Source-backed Markdown memory for Codex, Claude, Cursor, Kiro, VS Code, Copilot, Antigravity, and local agents. Local files. Inspectable sources. Budgeted context.

Try Link View on GitHub MCP Registry

The product

Not another notes app. A local memory layer agents can actually use.

Link turns raw notes, transcripts, project context, and explicit memories into a source-backed wiki. Agents query a compact packet instead of reading your entire folder.

Personal memory

Preferences, decisions, facts, and project context stay durable across agent sessions.

Source-backed wiki

Raw sources compile into Markdown pages with citations, backlinks, and reviewable provenance.

Agent-ready recall

One local memory works across CLI, skills, MCP-capable tools, and the local viewer through the same query, brief, graph, and memory lifecycle paths.

Budgeted context

Smart query packets return the right memory, pages, graph neighborhood, and follow-up actions without flooding tokens.

Measured scale

Health and benchmark commands show cache reuse, search backend, graph shape, and bounded payload behavior as a wiki grows.

Private by default

No hosted backend, no telemetry, no cloud lock-in. Your memory stays on disk as plain Markdown.

Auditable lifecycle

Capture, propose, approve, review, archive, restore, forget, and explain what Link remembers.

Obsidian-readable

Open the same wiki/ folder in Obsidian when you want a richer Markdown editor or graph view.

How it works

A local memory pipeline agents can trust.

Raw sources become structured wiki pages. Explicit remembers become reviewed memory. Agents retrieve compact context packets instead of reading your whole folder.

Link architecture: capture sources, structure wiki knowledge, review memory, and retrieve compact context
Link keeps the knowledge base plain and local while giving agents a predictable recall path.

Before and after

The useful moment is not storage. It is continuity.

Link is built for the daily handoff between sessions and agents: stop re-explaining the same context, start from a brief that has provenance.

Without Link

  1. Open a new agent session.
  2. Explain your project, preferences, and recent decisions again.
  3. Paste notes or ask the agent to scan a folder.
  4. Lose the context when you switch tools.
User: we talked about this yesterday...
Agent: I do not have that context.

With Link

  1. Ask: brief me from Link before we continue.
  2. The agent gets reviewed memory plus source-backed wiki context.
  3. Decisions can be remembered, reviewed, archived, or forgotten.
  4. Another MCP agent can recall the same local memory.
User: brief me from Link before we continue
Agent: Here is the relevant memory, sources, and next safe action.

First 2 minutes

Run a finished memory wiki locally.

The demo includes raw sources, wiki pages, one starter memory, backlinks, graph context, and a compact query packet.

First 10 minutes Troubleshooting 
# macOS/Homebrew proof loop
brew install gowtham0992/link/link
lnk demo
lnk next link-demo
lnk serve link-demo
lnk query "why does Link help agents?" link-demo --budget small
lnk brief "working on agent memory" link-demo
lnk benchmark "agent memory" link-demo

# source checkout proof loop
git clone https://github.com/gowtham0992/link.git
cd link
python3 link.py demo
python3 link.py next link-demo
python3 link.py serve link-demo
python3 link.py query "why does Link help agents?" link-demo --budget small
python3 link.py brief "working on agent memory" link-demo
python3 link.py benchmark "agent memory" link-demo

Access paths

Review it, script it, or let an agent call it.

The web UI, CLI, official skills, and MCP server all operate on the same local Markdown wiki. Read it like a local document, script it from a terminal, lazy-load a skill, or let an MCP client query the same memory.

No background web server required lnk serve only starts the human web viewer. The CLI, skills, and MCP server read the same local files directly, so agents can query Link when the viewer is closed.
Animated Link web UI walkthrough

Web UI

Read source-backed pages in a quiet local wiki, then jump to ingest, memory review, health, captures, and graph tools.

Animated Link CLI walkthrough

CLI

Run status checks, query packets, briefs, validation, backup, benchmark, and repair from a terminal.

Animated Link MCP agent walkthrough

MCP

Give Codex, Claude, Cursor, Kiro, VS Code, Copilot, and other agents the same local memory.

Visible trust

Memory is inspectable, reviewable, and explainable.

A memory is not a hidden vector. It is a Markdown page with status, scope, source, review state, graph links, and an audit trail.

Link memory dashboard
Memory dashboard: profile, inbox, captures, and review states.
Link explain memory view
Explain memory: why Link knows something and whether it is ready to recall.
Link graph view
Graph view: bounded by default, expandable when you need the whole neighborhood.

Agent contract

Agents get a small set of reliable moves.

Check readiness, brief before work, ingest raw files, remember explicit facts, query smart context, validate after writes, and explain why a memory exists.

BeforeRepeated context in every chat.
AfterShared local memory across agents.
StoragePlain Markdown and JSON indexes.
ScaleSQLite FTS, bounded graph payloads, local cache.

Read next

Start small, then make it your agent memory.

The docs are arranged by user path: try the demo, understand the model, choose MCP or skills, then use the CLI and maintenance tools when you need them.

First 10 minutes

Run the demo, add one source, save one direct memory, and verify the loop.

Why Link?

Understand where Link fits versus notes apps, hosted memory APIs, agent runtimes, and graph memory systems.

Web UI

Use the local viewer as a readable wiki with grouped memory, ingest, health, graph, and audit tools.

Concepts

Understand raw sources, wiki pages, memories, graph indexes, and budgeted query packets.

MCP setup

Install the MCP server and teach local agents how to use Link reliably.

CLI reference

Every local command, grouped by daily workflow and maintenance jobs.

Official skills

Use lazy-loadable CLI workflows when MCP setup is more than you need.

HTTP API

Local endpoints for status, query, memory, graph, validation, and web UI actions.

Security model

Local-first constraints, secret scanning, backup behavior, and HTTP safety boundaries.

Team security review

Deployment patterns, audit exports, Git sharing, approval gates, and current limits for small teams.

Contributing

PR expectations, test gates, branch policy, and what not to include in public changes.

Troubleshooting

Fix MCP setup, blocked ingest, stale graph indexes, slow wikis, and Python packaging issues.