Preface¶
DeepSeek Harness (dsh for short) treats models, tools, skills, conversations, sandboxes, storage, loops, scheduling, and UI as replaceable plugins—its official slogan is “Everything is a Plugin”. After installing Node.js, you can launch the web interface with this command:
npx @deepseek-ai/dsh web
Harness addresses the core problem of “how can agents work continuously in the real world”. When a conversation ends and context is compressed, the technical decisions, project agreements, and “why we didn’t do it this way” that were finalized just yesterday often disappear entirely. In the next conversation, the model will ask the same questions again or deliver a plan that conflicts with last week’s conclusions. This is not a failure of the model’s intelligence, but a failure of memory persistence beyond individual conversation sessions.
The community catalog categorizes such capabilities under the “Memory” taxonomy. Unlike other tools that “add another model into the memory pipeline”, mnemon treats the host LLM as a supervisor: the binary handles storage, graph indexing, retrieval, and forgetting decay, while the model only makes decisions about what to remember, how to form associations, and when to forget. This article is cross-checked against the community catalog details page, GitHub repository README / Chinese documentation / docs/USAGE.md / package.json / cordis.patch.yml, and the DeepSeek Harness official repository.
First, a critical source clarification: the community plugin directory deepseek-harness-plugin.com is an independent site with no official affiliation to DeepSeek / FunPlus. Do not treat it as an official app store. As of 2026-08-17, the GitHub repository mnemon-dev/mnemon has 463 stars; the catalog page lists 443 stars, categorizes the plugin as “Memory”, and marks it as featured. Both the repository LICENSE and catalog page use Apache-2.0; the root package.json for DSH installation additionally specifies MIT, so refer to the repository’s original text before installation. The current official release on GitHub is v0.2.3 (2026-08-16).
What is Mnemon¶
In one sentence: mnemon is a LLM-supervised persistent memory agent maintained by mnemon-dev. It uses a local SQLite graph storage to preserve decisions, facts, and reasoning across conversations, and leverages graph structure for recall rather than relying solely on hard keyword matching.
It is first and foremost a local binary written in Go, with data stored by default in ~/.mnemon, and no additional API keys required. The memory setup follows the “one executable, one install command” workflow. The same repository also includes a DSH installation entry: the root package.json has the package name @mnemon-dev/dsh-mnemon, depends on the community package dsh-mnemon, and uses cordis.patch.yml to inject the plugin into the current profile.
The catalog also lists another plugin dsh-mnemon (maintained by omdsh-dev). The repository README clarifies that on the DSH side, dsh-mnemon stacks three layers: runtime hot memory, managed project documentation, and Mnemon’s long-term memory; mnemon-dev/mnemon itself can also be used as a GitHub installation source. This article covers the mnemon listed on the catalog page, and the installation commands will follow the original text on that detail page.
Core Features¶
Verified capabilities, based on the repository README and docs/USAGE.md, can be divided into the following sections:
1. LLM Supervision, Instead of Embedding Another Model
Most memory tools run an additional LLM in the pipeline for extraction, scoring, or rewriting. Mnemon leaves the judgment up to the host model you are already using: the binary handles deterministic computations (storage, graph indexing, search, decay), while the model decides what to remember, how to form edges, and when to forget. The project lists this alongside three other common patterns: in-pipeline LLMs (e.g. Mem0, Letta), file injection at session start (e.g. Claude Code Memory), and tool provisioning via MCP (e.g. claude-mem).
There are only three primitives in its protocol: remember, link, and recall. The command names correspond to “remember / associate / recall”, and the output is structured JSON with transparent signal metadata rather than raw database rows.
2. Four Graphs, Instead of a Flat List
Memory should not be a growing, easily overlooked list of notes. The engine organizes edges using MAGMA’s four-graph model:
- Temporal
- Entity
- Causal
- Semantic
Recall defaults to intent-aware graph traversal, with an optional vector search overlay (RRF fusion). Without Ollama installed, core remember / recall / link and graph traversal still work; after installing a local Ollama instance (the documentation defaults to the nomic-embed-text model), recall anchors will switch to a hybrid of keywords + vectors + recency. The catalog page summarizes this as: agents can find facts by following associations like flipping through their own notes, which is ideal for projects where context is relational rather than flat.
3. Deduplication on Write, with Long-Term Decay
The remember command includes built-in diff logic: duplicates are skipped, and conflicts are automatically resolved by replacement. Memory retention decays with time and improves with access frequency, and garbage collection is provided. By default, all sessions share a store named default; you can also create named stores for individual projects, and switch between them using --store, the MNEMON_STORE environment variable, or the ~/.mnemon/active file.
4. Integration with DSH
The repository README’s instructions for DeepSeek Harness state: first install the mnemon binary on the host machine, then add the plugin to your web profile. After installation, go to Settings → Plugin Configuration → Mnemon to select the storage scope, and create or activate a memory bank in the session’s Memory System tab. Recall only reads from activated memory banks, and persistent writes are executed via a supervised sub-agent.
The included cordis.patch.yml defaults to mounting the plugin with id mnemon, name dsh-mnemon, and enables routing guidance, lifecycle management, guided recall/write, the memory tab, and write toggle. The default number of recall results is 10.
Installation and Activation¶
The installation command given on the catalog detail page is:
dsh plugin add github:mnemon-dev/mnemon
Run this in the DeepSeek Harness terminal. The dsh CLI will pull the plugin from GitHub and add it to your current configuration. For reproducible installations, pin the commit hash per the catalog page instructions:
dsh plugin add github:mnemon-dev/mnemon#<commit>
The repository README adds instructions for the web profile and the required installation order: “install the binary first, then add the plugin and restart”:
dsh plugin --profile web add github:mnemon-dev/mnemon
dsh --profile web
The standalone mnemon binary on the host machine requires separate installation. The repository provides these methods:
# macOS
brew install --cask mnemon-dev/tap/mnemon
# macOS / Linux / Windows (requires Go 1.24+)
go install github.com/mnemon-dev/mnemon@latest
# From source (macOS / Linux)
git clone https://github.com/mnemon-dev/mnemon.git && cd mnemon
make install
You can verify the installation with mnemon --version. Windows supports core Memory commands; the repository has an additional preview feature called Agency, which is currently unavailable on Windows and is separate from the memory workflow covered in this article, so it will not be discussed here.
Both the catalog page and the repository warn: the plugin runs with the permissions of the current dsh process, and may execute code during installation. Inspect the source repository and license before installing.
Typical Usage¶
The repository emphasizes that in daily use, you will typically not run mnemon commands manually—instead, the agent will call them when the guide judges “this memory is useful”. docs/USAGE.md marks the CLI as a reference for understanding, debugging, and advanced manual operations. The examples below are taken from the official documentation and can be used to verify what the agent is writing and reading.
Write an architectural decision:
mnemon remember "Chose Qdrant over Milvus for vector search" \
--cat decision --imp 5 --entities "Qdrant,Milvus" --tags "architecture,search" --source agent
Valid values for --cat include preference, decision, fact, insight, context, and general, with a default of general. --imp is an importance score from 1 to 5, with a default of 3.
Recall by intent (defaults to compact JSON suitable for model consumption):
mnemon recall "vector database" --limit 10
mnemon recall "why did we choose Qdrant" --intent WHY
mnemon recall "auth" --cat decision --source agent
Add --verbose to get full signals, metadata, and timestamps. Add --basic to perform only SQL LIKE matching without graph traversal.
Isolate memory per project:
mnemon store create work
mnemon store set work
MNEMON_STORE=work mnemon recall "query"
In the DSH web interface, the corresponding operations are: open the plugin configuration to select the storage scope, then activate the memory bank in the Memory System tab. The catalog page’s practical tip: treat this as a record system rather than a cache—feed decisions and reasoning into it, and the connections on the graph will become meaningful, preserving recall quality over time. If you also want to distill conversation history into the same store, the catalog page recommends pairing it with distill.
Optionally, after installing Ollama locally and pulling the nomic-embed-text model, use mnemon embed --status to check coverage, and mnemon embed --all to backfill vectors for existing entries. Without Ollama, the system will automatically detect this at runtime (the documentation specifies a 2-second timeout) and reallocate similarity weights to keyword and graph signals, with no separate “fallback switch” required.
Applicable Scenarios and Notes¶
The scenarios listed on the catalog page align with the repository’s positioning, and this tool is well-suited for the following types of work:
- Agents working on the same codebase for consecutive weeks: the graph accumulates project understanding rather than a flat, easily overlooked to-do list.
- Complex projects with relational context: recall needs to follow entities, causality, and semantics, rather than just keyword matches.
- Personal or small-team knowledge layers: projects, decisions, and reasoning—the very types of content that are most easily lost when a conversation ends or team members leave.
Keep these verified boundaries in mind when using the tool:
1. This is a community open-source project, not an official DeepSeek plugin. DeepSeek Harness is still in developer preview, and the official README notes that breaking changes may occur.
2. The plugin runs with the permissions of the current dsh process. Read the source code and license before installing; for production environments, pin the commit hash instead of tracking the latest tag.
3. The repository LICENSE is Apache-2.0; the root package.json specifies MIT. When both licenses are present, refer to the files you actually install, not just the one-line summary on the catalog page.
4. On the DSH side, recall only reads from activated memory banks; persistent writes go through a supervised sub-agent. Do not expect “automatic memory of everything” simply by installing the plugin without activating a memory bank.
5. The default store is shared across sessions. Use named stores or the storage scope in DSH for isolation, to avoid writing decisions from different projects into the same graph.
6. Vector enhancement relies on a local Ollama instance and is not required. If you switch embedding models with different output dimensions, the repository warns that existing vectors will become invalid and will need to be backfilled.
7. The dsh-mnemon listed in the catalog is a separate installation source (github:omdsh-dev/dsh-mnemon). The two are related, but have different maintainers and licenses (the latter’s catalog page uses MIT). Follow the commands for the specific plugin you are installing, and do not mix up names when concatenating commands.
Summary¶
For agents to work continuously on the same project, what is often missing is not more prompt engineering, but a memory system that persists across conversations and supports relational recall. mnemon distills this into a workflow where “the host LLM makes judgments, and the local binary handles storage”: four graph indexes, three primitives, and zero additional API keys. In DeepSeek Harness, the catalog entry provides a shortcut to add this GitHub repository to your current configuration, then select the scope and activate the memory bank in the plugin configuration and Memory System tab.
Catalog detail page: https://deepseek-harness-plugin.com/zh-CN/plugins/mnemon/
GitHub repository: https://github.com/mnemon-dev/mnemon