# Muse Memory — full site text

> Plain-text rendering of https://harshsinghmp.github.io/musememory/
> Generated from the built site. The repository README is the authoritative source.

---

# Muse Memory vs vector stores, graph platforms, session search

> Source: https://harshsinghmp.github.io/musememory/compare/

Muse Memory vs vector stores, graph platforms, session search Skip to content

MuseMemory (https://harshsinghmp.github.io/musememory/)
How it works (https://harshsinghmp.github.io/musememory/#how-it-works)Capabilities (https://harshsinghmp.github.io/musememory/#capabilities)Benchmarks (https://harshsinghmp.github.io/musememory/#proof)Docs (https://harshsinghmp.github.io/musememory/docs)

Get started (https://harshsinghmp.github.io/musememory/#install)
How it works (https://harshsinghmp.github.io/musememory/#how-it-works)Capabilities (https://harshsinghmp.github.io/musememory/#capabilities)Benchmarks (https://harshsinghmp.github.io/musememory/#proof)Docs (https://harshsinghmp.github.io/musememory/docs)GitHub ↗ (https://github.com/harshsinghmp/musememory)npm ↗ (https://www.npmjs.com/package/musememory)

Landscape

# Four approaches to agent memory

Vector stores optimize for semantic similarity, graph platforms for entity relationships, session search for retroactive lookup. Muse optimizes for the thing coding agents actually need: verified, code-grounded recall that never serves stale truth.

The differentiator: while other approaches serve memory at confidence, Muse verifies it at both write and recall. Notes are checked against your real code before they enter the store, and withheld if the code has drifted since they were written. Nothing is served as truth that cannot be traced to a structural anchor.

 Capability comparison between Muse Memory, dense vector stores, entity-relationship graph platforms, and session search tools.
 Capability Muse Memory local-first memory engine Vector stores dense embedding-based Graph platforms entity relationship-based Session search retroactive lookup-only

 Runs 100% local — zero daemons, zero cloud ✓ ✕ ✕ ✓

 Keyless mode (no LLM / embedding API) ✓ ✕ ✕ ~

 Sub-2ms in-process retrieval ✓ ✕ ✕ ~

 Write-time citation verification ✓ ✕ ✕ ✕

 Recall-time freshness gate (withhold stale) ✓ ✕ ~ ✕

 Deterministic lifecycle state machine ✓ ✕ ✓ ✕

 Structural code anchors (line-invariant) ✓ ✕ ✕ ✕

 Secret defense on every write path ✓ ✕ ✕ ~

 One command wires the majority of coding agents ✓ ~ ~ ~

 Git-reviewable memory files ✓ ✕ ✕ ✕

 Lifecycle hooks (hands-free capture/inject) ✓ ~ ~ ✓

 Token-budgeted fused context tool ✓ ~ ✕ ✕

 Scoped failure attribution & decaying strikes ✓ ✕ ✕ ✕

 Trajectory fix-pair negative memory mining ✓ ✕ ✕ ✕

✓ documented capability ·~ partial / requires setup or paid tier ·✕ not documented

Methodology: capability claims follow a documented-features-only standard — code beats docs, quick evolutions on all sides. Muse row reflects v3.2.0.

## Verified memory beats confident guesswork

Install now (https://harshsinghmp.github.io/musememory/#install)Read the docs (https://harshsinghmp.github.io/musememory/docs)

MuseMemory (https://harshsinghmp.github.io/musememory/)
Persistent, local-first memory for AI coding agents. Runs in-process on your machine — no account, no API key, no background daemon.

MIT licensed · v3.2.0 · 1,443 tests green

Product

Why agents forget (https://harshsinghmp.github.io/musememory/#problem)See it work (https://harshsinghmp.github.io/musememory/#demo)Architecture (https://harshsinghmp.github.io/musememory/#architecture)Benchmarks (https://harshsinghmp.github.io/musememory/#proof)

Docs

Docs home (https://harshsinghmp.github.io/musememory/docs)Quickstart (https://harshsinghmp.github.io/musememory/docs#quickstart)CLI reference (https://harshsinghmp.github.io/musememory/docs#cli)MCP tools (https://harshsinghmp.github.io/musememory/docs#mcp)

Code

GitHub (https://github.com/harshsinghmp/musememory)npm (https://www.npmjs.com/package/musememory)Changelog (https://github.com/harshsinghmp/musememory/blob/main/CHANGELOG.md)MIT licence (https://github.com/harshsinghmp/musememory/blob/main/LICENSE)

Agents

llms.txt (https://harshsinghmp.github.io/musememory/llms.txt)llms-full.txt (https://harshsinghmp.github.io/musememory/llms-full.txt)Agent reference (https://github.com/harshsinghmp/musememory/blob/main/docs/agent-reference.md)CLI reference (https://github.com/harshsinghmp/musememory/blob/main/docs/cli-reference.md)

Muse Memory — persistent memory for AI coding agents that verifies itself.

All data stays on your machine. Nothing is uploaded.

---

# Docs — Muse Memory

> Source: https://harshsinghmp.github.io/musememory/docs/

Docs — Muse Memory Skip to content

MuseMemory (https://harshsinghmp.github.io/musememory/)
Problem (https://harshsinghmp.github.io/musememory/#problem)Demo (https://harshsinghmp.github.io/musememory/#demo)Architecture (https://harshsinghmp.github.io/musememory/#architecture)Surface (https://harshsinghmp.github.io/musememory/#surface)Compare (https://harshsinghmp.github.io/musememory/#compare)Docs (https://harshsinghmp.github.io/musememory/docs)

Get started (https://harshsinghmp.github.io/musememory/#install)
Problem (https://harshsinghmp.github.io/musememory/#problem)Demo (https://harshsinghmp.github.io/musememory/#demo)Architecture (https://harshsinghmp.github.io/musememory/#architecture)Surface (https://harshsinghmp.github.io/musememory/#surface)Compare (https://harshsinghmp.github.io/musememory/#compare)Docs (https://harshsinghmp.github.io/musememory/docs)GitHub ↗ (https://github.com/harshsinghmp/musememory)npm ↗ (https://www.npmjs.com/package/musememory)

On this page

QuickstartCore conceptsCLI essentialsMCP tools that matterFailure attribution & negative mining (v3.0.0)Hands-free lifecycle hooksTrust gates

# Muse Memory documentation

Everything needed to run Muse Memory day to day: connect your agents, capture what matters, recall it in under two milliseconds. The complete command and tool reference lives in thegenerated CLI reference (https://github.com/harshsinghmp/musememory/blob/main/docs/cli-reference.md).

Reading this with an agent?

Point it at llms.txt (https://harshsinghmp.github.io/musememory/llms.txt) for the curated map, llms-full.txt (https://harshsinghmp.github.io/musememory/llms-full.txt) for the whole site as plain text, or theagent reference (https://github.com/harshsinghmp/musememory/blob/main/docs/agent-reference.md)for the exact CLI, MCP and file-layout contracts. Everything on this page is written to be read by a person, an agent, or both.

## Quickstart

Install, connect, verify — under two minutes, no API key, no account. One command wires Muse into the majority of the coding agents you already run, over MCP:

```
npx musememory connect # wire the agents you already run
npx musememory connect --with-hooks # + Claude Code lifecycle hooks
memory health # verify the store
```

## Core concepts

Memories live in .memory/ (project) and ~/.memory/ (global) as SQLite + YAML you can read, back up, or git. Every entry moves through a deterministic lifecycle: propose → candidate → confirmed → superseded, with an archival ladder (active → cold → dormant → archived) and query rehydration.

Memory types: fix (90d), operation (180d), architecture (365d), discovery (30d), preference (permanent), constraint (synced to CURRENT.md), session (timeline nodes).

## CLI essentials

```
memory capture "Auth uses jose" --type architecture
memory context --query "how does auth work" --budget 2000
memory propose "..." && memory confirm
memory supersede
memory capture --negative "Do not use X because Y"
memory hooks install # Claude Code hook pack
memory studio # web observability dashboard
memory optimize # prune noise + VACUUM (auto-cadence)
```

## MCP tools that matter

muse_context — flagship fused recall: constraints + ranked memories + negative lessons + code anchors under one token budget.

muse_why — traces code evolution backwards through ADRs and bug fixes before you refactor.

muse_memory_for_code / muse_code_for_memory — bidirectional code ↔ memory lookups.

memory_anchor_create / verify / audit — structural, line-invariant code anchors with write-time citation verification.

115 tools total, delivered through 7 task-focused profiles (core, coding, debugging, review, architecture, maintenance, full) so agents never face tool bloat.

## Failure attribution & negative mining (v3.0.0)

Scoped failure attribution: when a test or command fails, Muse verifies relevance against code anchors, affected paths, and reproduction commands before penalizing retrieved notes. Bystander memories are untouched, per-session retry spikes are deduplicated to 1 strike, and active strikes decay after 2 clean runs or 30 days.

Constitutional immunity: entries typed as constraint, timeless, or foundational (salience >= 0.95) are protected from automated dispute.

Fix-pair trajectory mining: automatically detects Error ➔ Remediation ➔ Success sequences in your session logs and distills actionable 'AVOID' negative memories with dynamic line number normalization and Vibeguard secret scrubbing.

HOT.md working set compounding: candidate memories from your active working set receive memoized sub-millisecond retrieval boosts with origin channel attribution (source:hot, source:fts).

LangMem frequency ranking: sub-linear logarithmic utility curves weight verified applications 2x over passive reads with fresh 7-day recency bonuses.

```
# Capture negative memory manually or let the harvester mine it
memory capture --negative "AVOID: jwt.sign without explicit algorithm"

# Query audit trail for strike and dispute operations
memory audit --operation regression_strike
memory audit --operation dispute_triggered
```

## Hands-free lifecycle hooks

memory connect --with-hooks wires the lifecycle pack into .agents/hooks.json: SessionStart injects constraints and top memories before your agent's first turn, PostToolUse captures tool results as observations, Stop distills the session into candidate memories. Every hook is fail-open — memory problems never block coding.

```
# .agents/hooks.json (managed by: memory hooks install)
{ "hooks": {
 "SessionStart": [{ "type": "command", "command": "memory hooks session-start" }],
 "PostToolUse": [{ "type": "command", "command": "memory hooks post-tool-use" }],
 "Stop": [{ "type": "command", "command": "memory hooks stop" }] } }
```

## Trust gates

Write time: Vibeguard scans every write against 8 credential rule families — AI API keys, GitHub and npm tokens, AWS keys, private key blocks, Slack tokens, credentialed connection strings and generic credential assignments (fail-fast); anchors are verified against the live filesystem and hallucinated citations are rejected.

Recall time: the freshness gate withholds memories whose anchors drifted or whose cited files vanished — reported, never silently served. Include them with muse_context include_drifted: true to get provenance warnings.

Sync time: P2P gossip packets are sealed, vector-clocked, deduplicated, and secret-scanned in both directions.

MuseMemory (https://harshsinghmp.github.io/musememory/)
Persistent, local-first memory for AI coding agents. Runs in-process on your machine — no account, no API key, no background daemon.

MIT licensed · v3.2.0 · 1,443 tests green

Product

Why agents forget (https://harshsinghmp.github.io/musememory/#problem)See it work (https://harshsinghmp.github.io/musememory/#demo)Architecture (https://harshsinghmp.github.io/musememory/#architecture)Benchmarks (https://harshsinghmp.github.io/musememory/#proof)

Docs

Docs home (https://harshsinghmp.github.io/musememory/docs)Quickstart (https://harshsinghmp.github.io/musememory/docs#quickstart)CLI reference (https://harshsinghmp.github.io/musememory/docs#cli)MCP tools (https://harshsinghmp.github.io/musememory/docs#mcp)

Code

GitHub (https://github.com/harshsinghmp/musememory)npm (https://www.npmjs.com/package/musememory)Changelog (https://github.com/harshsinghmp/musememory/blob/main/CHANGELOG.md)MIT licence (https://github.com/harshsinghmp/musememory/blob/main/LICENSE)

Agents

llms.txt (https://harshsinghmp.github.io/musememory/llms.txt)llms-full.txt (https://harshsinghmp.github.io/musememory/llms-full.txt)Agent reference (https://github.com/harshsinghmp/musememory/blob/main/docs/agent-reference.md)CLI reference (https://github.com/harshsinghmp/musememory/blob/main/docs/cli-reference.md)

Muse Memory — persistent memory for AI coding agents that verifies itself.

All data stays on your machine. Nothing is uploaded.

---

# Muse Memory — Persistent, self-verifying memory for AI coding agents

> Source: https://harshsinghmp.github.io/musememory/

Muse Memory — Persistent, self-verifying memory for AI coding agents Skip to content

MuseMemory (https://harshsinghmp.github.io/musememory/)
Problem (https://harshsinghmp.github.io/musememory/#problem)Demo (https://harshsinghmp.github.io/musememory/#demo)Architecture (https://harshsinghmp.github.io/musememory/#architecture)Surface (https://harshsinghmp.github.io/musememory/#surface)Compare (https://harshsinghmp.github.io/musememory/#compare)Docs (https://harshsinghmp.github.io/musememory/docs)

Get started (https://harshsinghmp.github.io/musememory/#install)
Problem (https://harshsinghmp.github.io/musememory/#problem)Demo (https://harshsinghmp.github.io/musememory/#demo)Architecture (https://harshsinghmp.github.io/musememory/#architecture)Surface (https://harshsinghmp.github.io/musememory/#surface)Compare (https://harshsinghmp.github.io/musememory/#compare)Docs (https://harshsinghmp.github.io/musememory/docs)GitHub ↗ (https://github.com/harshsinghmp/musememory)npm ↗ (https://www.npmjs.com/package/musememory)

v3.2.0 · Runs on your machine · No account · MIT

# Persistent, self-verifying memory for AI coding agents

Muse stores what your agent learned — the decisions, the fixes, the constraints — checks every note against the code it cites, and hands back only what still holds. In-process, sub-2ms, no daemon.

```
npx musememory connect
```

 Copy

Get memory in one commandRead the docs (https://harshsinghmp.github.io/musememory/docs)

**Recall latency**
sub-2ms

**Hot cache lookup**

The problem

## Why your agent forgets everything by Thursday

An assistant only knows what fits in its context window. When the session ends that context is discarded, so the next session starts from zero — and the cost compounds every time you re-explain something that was settled yesterday.

### Every session starts from zero

You re-explain the architecture, the auth flow, the one decision nobody else understands. Every morning. The context window is a scratch pad, not a notebook.

### Memory that ignores your git state

Check out a hotfix and the agent still applies rules from the branch you abandoned. Stale facts leak into stable code and nobody notices until it ships.

### A flat MEMORY.md is a cache killer

Every edit invalidates the whole prefix. You pay to re-read the same context each session, and the file becomes nobody's source of truth.

### No blame, no rollback

A hallucinated rule poisons every future recall. There is no `git blame` for memory, no checkout, no way back to the state before the mistake.

Show, don't tell

## Every memory gets one of three outcomes

Nothing is stored on faith. A note is either confirmed against the code it cites, refused because that code does not exist, or withheld because the code moved on since — and in that last case you are told why.

Ten seconds on the engine's story — every number on screen is a measured benchmark, not a claim.

- ✓Rememberedauth uses jose, not jsonwebtokenThe cited symbol exists — handed back next session.
- ✕Refusedsee src/legacy/auth.tsThe file does not exist — the write never happens.
- !Withheldsession store uses RedisThe code drifted since the note — held back, and you are told why.

How it works

## Your data never leaves the machine

Muse runs as a process you start and stop. There is no server to operate, no account to create, and no network call in the path of a recall. The whole engine is a SQLite database and a folder of YAML files you can open in any editor.

One process, two scopes. Project memory travels with the repo; global memory holds the preferences that follow you.

 01

### Remember it

When your agent makes a decision or fixes a bug, Muse saves a short note — what changed and why.

Every write passes a credential scan first, and the note lands as a readable YAML file beside a SQLite row.

 02

### Check it

Before the note is stored, Muse confirms the file or function it mentions actually exists.

Citations are structural fingerprints, not line numbers, so moving a function does not silently break the note.

 03

### Hand it back

Next session, Muse returns the notes that fit the task — sized to your budget, not the whole archive.

One in-process query over SQLite FTS5. Under 2ms, with a hard token ceiling. No daemon, no network, no model call.

### Everything is a file you can read

Delete the folder and the memory is gone. Commit it and memory becomes code — reviewable in a pull request, revertible with`git revert`.

```
.memory/ # project scope
├── memory.db # SQLite: memories, anchors, graph
├── memories/ # one YAML file per memory
├── CURRENT.md # active constraints
├── USER.md # your persona
├── observations.jsonl # the event log the harvester mines
└── audit.jsonl # tamper-evident write ledger

~/.memory/ # global scope
```

The surface

## Real commands, real tools

Every capability below is something you can run right now. No dashboards to configure, no workflows to author — a command, or a tool your agent calls.

### One command wires your tools

Muse detects the coding agents you already run and connects the memory server to each one over MCP — with no permission prompts and no config file to hand-edit.

```
npx musememory connect
```

### Writes are scanned, not trusted

Every write — capture, import, sync packet — is matched against credential patterns first. A suspected secret stops the write instead of landing in a file you might later commit.

```
memory capture "auth uses jose" --project core
```

### Citations are verified at write time

A note that points at a file or function which does not exist is rejected on the spot. Hallucinated citations never reach the store.

```
memory anchor create --file src/auth.ts --symbol verify
```

### Stale notes are withheld, not served

At recall time Muse re-checks every citation. If the code moved on, the note is held back and reported — never handed over as if it were still true.

```
muse_context # returns withheld_memories + freshness_notice
```

### Memory is versioned like code

Scope memory to a branch, blame a note back to the session that wrote it, and roll back to a known-good state. Git for AI memory.

```
memory branch m_1700… --path core/auth
memory blame m_1700…
```

### Failures become permanent lessons

Muse watches the error → fix → no-recurrence sequence in your session logs and distills a negative memory, so the same mistake is not made twice.

```
memory capture --negative "AVOID: jwt.sign without an explicit algorithm"
```

Proof

## Measured, not claimed

Recall takes under two milliseconds because it is a local database query, not an API call. The hot cache answers in under fifty microseconds. Run `memory benchmark` to reproduce every number on this page.

Latency on the same machine, same store. The network row is a reference point, not a Muse claim.

**Recall latency**
sub-2ms
SQLite FTS5 BM25, in-process

**Hot cache lookup**

### Four gates, every time

 On every write Credential scan The write is refused and the rule is named. The value is never echoed.

 On every write Citation check A note citing a file or symbol that does not exist is refused.

 On every recall Freshness gate Notes whose code drifted are withheld and reported, not served.

 On every import Context stripping Injected context blocks and base64 payloads are removed before storage.

Lifecycle

## Notes have a life, and an end

Nothing is written and forgotten. Every note moves through a deterministic lifecycle, decays on a schedule tied to how much you trust it, and can be restored if you delete it by mistake.

`confirmed` is the only state served by default. A deletion is a tombstone — `memory restore` brings it back.

Landscape

## How it is different

Vector stores optimise for similarity and graph platforms for relationships. Muse optimises for what a coding assistant actually needs: recall that is fast, local and tied to your code — and that never passes off a stale fact as current.

 Capability comparison between Muse Memory, dense vector stores, and entity-relationship graph platforms.
 Capability Muse Memory Vector stores dense embedding-based Graph platforms entity relationship-based

 Runs 100% local, zero daemons ✓ ✕ ✕

 No API key required ✓ ✕ ✕

 Sub-2ms retrieval, in-process ✓ ✕ ✕

 Write-time citation verification ✓ ✕ ✕

 Recall-time freshness gate ✓ ✕ ✕

 Deterministic lifecycle state machine ✓ ✕ ✓

 Structural anchors that survive refactors ✓ ✕ ✕

 Secret scanning on every write ✓ ✕ ✕

 One command wires your agents ✓ ✕ ✕

 Memory files you can review in git ✓ ✕ ✕

Generalizations — each platform evolves quickly, so check their docs. The Muse column reflects v3.2.0.

See the full comparison → (https://harshsinghmp.github.io/musememory/compare)

Get started

## One line. That's the whole setup.

Open a terminal in your project, paste the line, press enter. Muse finds the coding agents you already run and connects each one over MCP, with only the tools its task needs. Time to first value: under a minute.

- 1 ### Paste one line No install step, no config file, no account. ``` npx musememory connect ```
- 2 ### Let it wire your tools Each agent gets the memory tools its task needs — nothing more. ``` memory hooks install # optional: hands-free recall ```
- 3 ### Keep working Ask why something is the way it is — your agent can now look it up. ``` memory context --query "how does auth work" --budget 2000 ```

 CLI 80+ commands, scriptable, no daemon

 MCP 115 tools over stdio

 Profiles 7 task-shaped tool sets

 Files YAML + SQLite, yours to read

Everything stays on your machine. Read the docs (https://harshsinghmp.github.io/musememory/docs),point your agent at llms.txt (https://harshsinghmp.github.io/musememory/llms.txt), orread the source (https://github.com/harshsinghmp/musememory).

## Free forever. No paid tier, no telemetry.

Muse is MIT-licensed. The whole engine — capture, ranking and recall — runs in-process on your machine, so there is no hosted component to charge for and nothing to phone home about. Clone it, fork it, ship it inside your product.

Install from npm (https://www.npmjs.com/package/musememory)Read the source ↗ (https://github.com/harshsinghmp/musememory)

**Licence**
MIT

**Cost**
Free

**Account**
None

**Telemetry**
None

**Network calls**
None by default

**Background daemons**
0

Plain English

## Words in this page, explained

No prior knowledge assumed. Skip it if you already live in a terminal.

**AI coding agent**
An AI assistant that reads and edits code in your project — Claude Code, Cursor, Codex, Windsurf and similar tools.

**Agent memory**
What an assistant keeps between sessions: decisions, fixes and preferences it can look up later instead of rediscovering.

**Context window**
The fixed amount of text an assistant can consider at once. Anything outside it is invisible — which is why sessions forget.

**MCP**
Model Context Protocol — the standard way assistants connect to outside tools like Muse. You never have to use the acronym.

**Local-first**
The data lives and is processed on your own machine. No account, no upload, no service that can go down or change its pricing.

**Code anchor**
A pointer from a note to a specific file or function. Muse uses a structural fingerprint instead of a line number, so refactors do not break it.

FAQ

## Questions people ask before installing

 Do I need to know how to program to install it?
No, but you do need a terminal. The setup is one line you paste and run — no config file to write, no server to set up, no account to create.

 Do I need an API key or a subscription?
No account, no API key, no subscription. Muse is MIT-licensed and free. It never calls a model: recall is a database query on your own machine, so there is nothing to bill.

 Where is my data stored?
Two folders on your computer: .memory/ inside each project, and ~/.memory/ for anything that applies everywhere. Plain SQLite and YAML you can read, edit, back up, ignore, or commit to git. Nothing is uploaded.

 Will it slow my assistant down?
No. A lookup runs in under two milliseconds locally with a hard token budget, so it returns a short list rather than everything. That is far cheaper than re-explaining your architecture in every new session.

 Does it work with the tools I already use?
Yes. Muse connects to the majority of the coding agents people actually run — Claude Code, Cursor, Codex, Windsurf, Gemini CLI, OpenCode, Hermes, OpenClaw and the rest of the mainstream field. One command wires each of them; you keep working exactly as you do today.

 What if it remembers something wrong?
Muse checks citations before storing them and re-checks them at recall. If the code a note points at has changed or disappeared, the note is withheld and you are told why, rather than served as if it were still true. Contradictions are marked conflicted instead of silently overwritten.

 What happens to passwords and API keys?
They are refused. Every write is scanned for API keys, tokens, private keys and connection strings, and a suspected secret stops the write instead of being stored in a file you might later commit.

 Can I bring my existing notes?
Yes. The importer reads other memory systems, and existing session transcripts can be turned into candidate notes. Your memory starts populated rather than empty.

 Is it really free?
Yes. MIT-licensed, no paid tier, no telemetry. The whole engine — capture, ranking and recall — runs in-process on your machine, so there is no hosted component to charge for.

## Stop re-explaining. Start remembering.

One command connects every assistant you use. The memory verifies itself from there.

Install nowRead the source ↗ (https://github.com/harshsinghmp/musememory)

MuseMemory (https://harshsinghmp.github.io/musememory/)
Persistent, local-first memory for AI coding agents. Runs in-process on your machine — no account, no API key, no background daemon.

MIT licensed · v3.2.0 · 1,443 tests green

Product

Why agents forget (https://harshsinghmp.github.io/musememory/#problem)See it work (https://harshsinghmp.github.io/musememory/#demo)Architecture (https://harshsinghmp.github.io/musememory/#architecture)Benchmarks (https://harshsinghmp.github.io/musememory/#proof)

Docs

Docs home (https://harshsinghmp.github.io/musememory/docs)Quickstart (https://harshsinghmp.github.io/musememory/docs#quickstart)CLI reference (https://harshsinghmp.github.io/musememory/docs#cli)MCP tools (https://harshsinghmp.github.io/musememory/docs#mcp)

Code

GitHub (https://github.com/harshsinghmp/musememory)npm (https://www.npmjs.com/package/musememory)Changelog (https://github.com/harshsinghmp/musememory/blob/main/CHANGELOG.md)MIT licence (https://github.com/harshsinghmp/musememory/blob/main/LICENSE)

Agents

llms.txt (https://harshsinghmp.github.io/musememory/llms.txt)llms-full.txt (https://harshsinghmp.github.io/musememory/llms-full.txt)Agent reference (https://github.com/harshsinghmp/musememory/blob/main/docs/agent-reference.md)CLI reference (https://github.com/harshsinghmp/musememory/blob/main/docs/cli-reference.md)

Muse Memory — persistent memory for AI coding agents that verifies itself.

All data stays on your machine. Nothing is uploaded.