Preface

Running agents in DeepSeek Harness (DSH) struggles with long projects, even with large context windows: preferences and collaboration agreements must be repeated every round, design documents are scattered across the repository, and cross-session facts are easily lost. Stuffing everything into a single vector store leads to noisy retrieval, hard-to-manage writes, and agents might even alter memory when they shouldn’t.

dsh-mnemon is a memory plugin maintained by community contributor omdsh-dev, currently categorized under “Memory” in the SkillHub Plugin Directory. It has about 205 GitHub stars, 10 forks, and is licensed under MIT. It provides a unified memory control plane for DSH: runtime context, searchable project archives, and pluggable long-term memory spaces, combined with a WebUI, Headless tools, and supervised agent workflows to clarify “what to remember, where to store it, and how to recall it.”

It should be noted: SkillHub is a DSH plugin community directory for Chinese users, with no official affiliation with DeepSeek / High-Flyer; DSH itself operates on the philosophy of “everything is a plugin,” and such directories facilitate discovery and installation but do not equate to an official app store.

What This Is

In one sentence: dsh-mnemon is a three-tier, pluggable, agent-driven memory system for DeepSeek Harness—it does not require all knowledge to be stored in the same database, but uses a layered approach with Runtime, Documents, and Memory Spaces, with the third layer’s backend switchable among nine providers.

Maintained by omdsh-dev, source repository: https://github.com/omdsh-dev/dsh-mnemon. The current npm package version is 0.3.0 (as per the repository’s package.json), and the official README states it has been verified on DSH 0.1.1-rc.2.

Core Features and Highlights

Three-Tier Memory, Each Managing a Type of Knowledge

Tier Best For How It Enters the Agent Managed By
Runtime Preferences, collaboration rules, project agreements, environment facts Injected each round via compact USER.md / MEMORY.md projections Deterministic management by dsh-mnemon Host
Documents Designs, investigations, processes, post-mortems, handover materials Retrieved first, then read as full Markdown on demand Deterministic management by dsh-mnemon Host
Memory Spaces Cross-session facts, decisions, entities, and relationships Bounded evidence recalled from activated memory spaces Mnemon Native or external providers

A simple rule of thumb: Runtime for what’s needed every round, Documents for complete reads, Memory Spaces for cross-task recalls as needed. Current instructions, repository files, and real-time tool results always take precedence over historical memory—the three tiers are not copies of the same content.

Nine Long-Term Memory Providers, Third Layer Replaceable

The official primary native engine is Mnemon (local CLI + SQLite). Besides Mnemon, Memory Spaces can also interface with providers like OpenViking, Honcho, Mem0, Hindsight, Holographic, RetainDB, ByteRover, and Supermemory. The storage and workspace interaction models for the first two tiers do not change with the provider; external providers are disabled by default and require explicit enabling.

Agent-Driven + Host-Controlled Write Path

Write operations such as “distill memory” or “store to memory” go through a dedicated task agent for judgment, routing, deduplication, and refinement, with the host controlling whether to actually write; “retrieval” and “this-round memory” are deterministic, host-controlled read-only paths. The task agent does not by default compete with the main conversation history, and a dedicated model route can be specified in Settings → Memory System → Background Task Agent.

Multiple Entry Points Sharing One System

  • Sidebar WebUI: Status, Runtime, Documents, Memory Spaces, provider configuration, and visualization
  • Conversation UI: This-round memory, store to memory, jump to corresponding pages
  • Headless: Supports runtime injection, document retrieval, memory space tools, and supervised writes even without the WebUI
  • Slash Commands: /mnemon status, recall, related, remember, forget

From v0.3.0 onwards, the three tiers become the default topology in the composable core: MemoryBoot assembles extension points like Layers, Adapters, Strategies, and Guards, while users only need to install a single dsh-mnemon package.

Installation and Enabling

The plugin runs with the current dsh process permissions. Before installation, it is recommended to read the source code and MIT license to confirm you accept its data and security boundaries (noted in the precautions below).

Mnemon is the default and simplest local-first starting point:

# macOS
brew install --cask mnemon-dev/tap/mnemon

# macOS / Linux, also installable via Go
go install github.com/mnemon-dev/mnemon@latest

mnemon --version

Windows can install the official ZIP for v0.2.3 or higher; details are in the repository’s Getting Started documentation.

2. Install DSH and the Plugin

The official README suggests fixing the DSH version in reproducible scenarios. DSH 0.1.1-rc.2’s full profile requires Node.js ^22.19.0 || >=24.0.0 (Node 20 lacks some host primitives used by rc.2); the dsh-mnemon package itself still retains compatibility with Node 20 to support older DSH Hosts.

npm install -g @deepseek-ai/dsh@0.1.1-rc.2
dsh --version

Install the plugin for web interaction scenarios (each profile’s plugin list is independent):

dsh plugin --profile web add dsh-mnemon
dsh --profile web

For one-off Headless tasks, install separately:

dsh plugin --profile headless add dsh-mnemon
dsh --profile headless "Check persistent project context before answering."

For local development checkouts, you can link via absolute path:

dsh plugin --profile web add "link:/absolute/path/to/dsh-mnemon"
dsh plugin --profile headless add "link:/absolute/path/to/dsh-mnemon"

You can also install from a GitHub repository (equivalent to the common github:owner/repo syntax on directory pages):

dsh plugin --profile web add github:omdsh-dev/dsh-mnemon

Typical Usage Examples

After installation, you can follow the official “5-minute verification” workflow for the first run:

  1. Open Memory System → Status to confirm dsh-mnemon, Mnemon Native, Runtime, Documents, and enabled providers are functioning correctly;
  2. Open Memory Spaces → Overview → Create Memory Space, manually select an enabled provider;
  3. Submit a stable, future-useful candidate piece of information via Distill Memory;
  4. In Retrieval, first perform a direct search, then execute an Agent Query on the same question (read-only, organizing answers based on bounded evidence);
  5. Return to the conversation, expand This-Round Memory, and click an entry to jump to its source.

For Headless scenarios, you can start directly with a task:

dsh --profile headless "Check durable project context before answering this task."

Within a conversation, you can also use commands for quick operations, such as checking status or recalling:

/mnemon status
/mnemon recall decisions about database migration in the project

The page order in the WebUI remains stable: Status, Runtime, Documents, Memory Spaces—familiarity with this order saves considerable time in daily maintenance.

Applicable Scenarios and Precautions

Who It’s For:

  • Those doing long-term coding, research, or operations agent work on DSH, needing to preserve project agreements and decisions across sessions;
  • Those who prefer layered management for Runtime / documents / long-term memory instead of “one RAG store for everything”;
  • Those with existing memory services like Mem0, Honcho, etc., wanting to orchestrate and switch providers within DSH;
  • Those who need both WebUI visualization for maintenance and Headless read/write for in-context memory in CI / scripts.

Before Use, Please Note:

  1. Permissions and Security: The plugin runs with the same process permissions as DSH; provider credentials are stored locally in state/memory-providers.json (mode 0600) but are not sent back to the browser. No layer should write secrets, tokens, or raw sensitive logs—there is currently no deterministic secret scanner.
  2. Data Lifecycle: Runtime and Documents are local deterministic storage; disabling a provider only clears local directory metadata, not remote data; uninstalling the plugin does not delete local or remote memory data; switching between global / workspace / custom scopes does not automatically migrate old root directories.
  3. Environment Version: To use DSH 0.1.1-rc.2’s full capabilities, please prepare Node 22.19+ or 24+; older hosts inconsistent with the README’s verification matrix may encounter compatibility issues.
  4. Community Nature: Stars and forks change over time; at the time of writing, the SkillHub directory showed about 205 stars—base your assessment on real-time data when you open the directory page or GitHub.

Conclusion

dsh-mnemon breaks down the memory problem in DSH—which tends to “get messier with use”—into three tiers: Runtime, Documents, and Memory Spaces, while leaving provider plug-and-play space in the third tier; the write path is constrained by both the Host and task agents, while the read path remains as deterministic as possible. If you’re adding long-term memory to a Harness agent, it’s worth starting with the default Mnemon Native and then connecting external engines as project needs arise.