7 DeepSeek Harness Memory Plugins Compared (2026)

DeepSeek Harness (dsh) has no official long-term memory feature — that's a documented gap, not an oversight you've missed. What it does have is a context compaction system, plus a wide-open plugin ecosystem that's produced at least seven cross-session memory plugins and three official example configs for wiring in a memory-flavored MCP server. This roundup compares all of them.

The picks at a glance

Plugin	Stars	Approach	Link
dsh-mnemon	16	Three-tier: Runtime / Documents / Memory Spaces	Plugin
distill	15	Background subagent reflection → skill create/update	Plugin
dsh-mneme	9	SQLite + Markdown mirror, background consolidation	Plugin
dsh-memento	3	Approval-gated ctx.memory seam, SQLite provider	Plugin
dsh-memory (jesse-njx)	2	Citations back to exact session-log excerpts	Plugin
dsh-memory-gate	2	FTS5 claims with explainable recall + audit trail	Plugin
dsh-memory-meow	2	Project-scoped PROJECT.md snapshot	Plugin

All seven are pulled from the memory category in FindHarness's curated (source: awesome) index. None of them are official DeepSeek products — see the "why no built-in memory" section below for what dsh does ship.

Why dsh doesn't have built-in memory

Two facts explain the gap. First, dsh does ship official context compaction — packages like compaction/compaction, compaction/compaction-basic, and compaction/compaction-tool-result-pruner, plus a /compact human command — but compaction manages what fits in a single session's context window, not what persists across sessions. Second, "long-term memory" is one of the highest-engagement open requests in the project's GitHub Discussions: Discussion #14 ("求一个memory能力") has around 30 comments and no official response indicating it's on a near-term roadmap.

That gap is exactly why the plugin ecosystem filled it in with at least seven independent takes, plus the official examples covered below for anyone who'd rather bring in an MCP server instead of a dsh-native plugin.

The seven memory plugins

1. dsh-mnemon — three-tier memory model

github.com/omdsh-dev/dsh-mnemon · 16 stars · MIT · npm: dsh-mnemon

Integrates "Deep Mnemon" with a three-tier structure: Runtime Memory (short-lived, in-session), retrievable Documents, and supervised Memory Spaces (a curated, higher-trust tier). The tiering is the distinguishing idea here — not every memory plugin separates "things the agent noticed" from "things a human vetted."

dsh plugin --profile web add dsh-mnemon

2. distill — automatic conversation distillation

github.com/loserfox/distill · 15 stars

Runs a background subagent that reflects on conversations and creates or updates skills from what it learns — a different mental model from most entries here, which store facts. distill instead turns recurring patterns into reusable skill definitions, closer to "the agent teaches itself a new capability" than "the agent remembers a fact."

dsh plugin --profile web add github:loserfox/distill

3. dsh-mneme — SQLite with a human-editable mirror

github.com/modusensus/dsh-mneme · 9 stars · MIT

Cross-session memory backed by SQLite, with a human-editable Markdown mirror kept in sync — so you can read and hand-edit what the agent remembers without a database client. It runs background consolidation (deduplication, merging, conflict resolution) and exposes six memory tools. The Markdown mirror is the standout feature: most memory plugins are black boxes you can only inspect through a tool call.

dsh plugin --profile web add github:modusensus/dsh-mneme

4. dsh-memento — approval-gated and auditable

github.com/perrylink/dsh-memento · 3 stars · Apache-2.0 · npm: dsh-memento

The most security-conscious design in this list: a typed ctx.memory capability seam with a zero-dependency SQLite provider, a memory tool, and frozen snapshot injection. Every write passes through dsh's approval gate (the same ask/never mechanism that guards file writes and shell commands), and the memory store stays reconstructable from the session log — meaning you're never trusting a black-box database as the sole source of truth. If you're wary of an agent silently accumulating persistent state, this is the plugin built around that exact concern.

dsh plugin --profile web add dsh-memento

5. dsh-memory (jesse-njx) — cited memory

github.com/jesse-njx/dsh-memory · 2 stars · MIT

Distilled facts here carry (sessionId, eventRange) citations that expand back to the exact original log excerpt they were derived from. This directly answers a common worry with any summarization-based memory system — "did the agent actually say/see that, or did it hallucinate a fact during distillation?" — by keeping a traceable link to the source.

dsh plugin --profile web add github:jesse-njx/dsh-memory

6. dsh-memory-gate — explainable, bounded recall

github.com/git121995/dsh-memory-gate · 2 stars · MIT

Bounded local memory with what the author calls "CBDC authority gating": SQLite + FTS5-backed claims, scoped recall with explainable use/verify/ignore decisions and a full audit trail, /memory human commands, and a hard cap of roughly 3 claims / 1,200 characters injected per call — with no extra model call required to decide what to inject. The injection cap and "no extra model call" design are notable if you're worried about memory retrieval quietly inflating your token bill.

dsh plugin --profile web add github:git121995/dsh-memory-gate

7. dsh-memory-meow — project-scoped memory

github.com/phant0meow/dsh-memory-meow · 2 stars · MIT

Scopes memory to the project rather than the user or the agent: a PROJECT.md snapshot gets injected into the first user message of a session, a memory_remember tool lets the agent add to it, and it auto-reflects after ReAct-style tasks. Each project keeps its own separate memory file, which matters if you run dsh across multiple unrelated codebases from the same machine and don't want memory bleeding between them.

dsh plugin --profile web add github:phant0meow/dsh-memory-meow

The official alternative: MCP memory servers

If you'd rather not depend on a community plugin for something as sensitive as persistent memory, dsh's official MCP client is a documented, first-party path to the same outcome — you connect an external MCP server rather than installing a dsh-specific plugin. The dsh repository ships three example configs specifically for this under examples/mcp-memory/:

examples/mcp-memory/engram.cordis.yml
examples/mcp-memory/mcp-reference-memory.cordis.yml
examples/mcp-memory/memorix.cordis.yml

Each wires up a different memory-flavored MCP server as a @deepseek-ai/dsh-mcp-client instance. Recall that MCP support in dsh only bridges Tools, not Resources or Prompts — so whatever memory server you connect needs to expose its retrieval/storage operations as callable tools, not as MCP resources, for dsh to actually use them.

Choosing between plugin and MCP

There's no single right answer, but the shape of the trade-off is consistent:

• A dsh-native plugin (any of the seven above) is simpler to install (dsh plugin add) and typically runs in-process, but you're trusting a community-maintained storage layer specific to dsh.
• An MCP memory server decouples memory from dsh entirely — the same server could serve other MCP-compatible tools too — at the cost of running and maintaining a separate process, and being limited to whatever the server exposes as Tools.

If auditability matters most, dsh-memento's approval-gated design and dsh-memory-gate's audit trail are the two built specifically around that concern. If you want memory that survives a switch away from dsh entirely, the MCP path is the more portable choice.

FAQ

Does DeepSeek Harness remember anything between sessions by default?

No. Without a memory plugin or MCP server, each dsh session starts fresh apart from what's on disk in your workspace (files, AGENTS.md/CLAUDE.md, git history). Context compaction manages what fits within one session — it doesn't persist facts to a new session.

Is this the same thing as context compaction?

No — compaction (/compact, the compaction-* packages) reduces token usage within an active session by summarizing or pruning old turns. Memory plugins add a separate, explicit persistence layer that survives across sessions entirely.

Which memory plugin has the most installs or usage?

FindHarness only tracks GitHub stars, and none of these plugins have a wide gap — dsh-mnemon leads at 16. Star count is a rough popularity signal, not a usage or reliability metric; read each README before committing.

Can I use more than one memory plugin at once?

Technically nothing stops you from installing two, but most of these register their own tools and, in some cases, their own storage schema — running two in parallel is likely to produce confusing, duplicated recall rather than a better result. Pick one.

Are any of these plugins reviewed or endorsed by DeepSeek?

No. All seven are community projects surfaced through the dsh-plugin GitHub topic and the awesome-dsh-plugin list; none are published under the deepseek-ai organization. See our plugin security checklist before installing.

Next steps

For the full mechanics of connecting an MCP server (transport options, tool naming, reconnection behavior), see How to Use MCP Servers with DeepSeek Harness. Browse the complete memory category at /categories/memory, or start with How to Install DeepSeek Harness Plugins if this is your first plugin install.