How MemSearch Turns DSH Plugins into Agent Self-Evolution
26 Aug 2026 - Cheney Zhang
DeepSeek Harness (DSH) has a simple promise: everything is a plugin.
MemSearch, the agent memory framework we have been building, is now available as a DSH plugin.
It gives DSH three practical capabilities:
First, persistent memory. Your work and decisions survive across days and sessions instead of disappearing with the chat window.
Second, memory shared across agents. The same memory can move naturally between Claude Code, Codex, and DSH. You can pick up in DSH where you left off in another coding agent, without manually migrating anything.
Third, self-evolution. Memory does more than replay the past. It can develop into reusable capabilities that make DSH better suited to the way you work. This is the most interesting part, and we will come back to it last.
You can add MemSearch to DSH with two commands:
uv tool install "memsearch[onnx]"
dsh plugin --profile web add @zilliz/memsearch-dsh
Let’s look at what each capability means in practice.
1. Giving DSH a Memory That Persists
Most agent memory systems offer some form of long-term memory. The difference lies in how much they retain and how deeply that memory is integrated into the workflow.
With MemSearch, DSH persistently records your work across sessions, however long a project runs. Relevant history remains available through semantic search whenever the agent needs it.
Once the plugin is installed, there is nothing else to do. You chat and write code as usual, and MemSearch captures the history automatically. When you return to a topic later, the agent can retrieve the relevant discussion: what you were trying to do, how the agent helped, and why a particular decision was made.
These questions come up all the time on long-running projects:
“I think I planned this feature before. What was the original idea?”
“Why did we decide to use Postgres?”
MemSearch is designed to preserve more than the final state. It also preserves the path that led there. That history makes it possible to trace decisions, reflect on earlier reasoning, and continue developing a project over time. Newer open-source memory frameworks such as MemPalace follow a similar idea. To us, this is where long-term memory becomes genuinely useful.
2. Making Memory Portable Across Agents
Shared memory is more useful than it might sound.
Memory accumulated in Claude Code becomes available in DSH as soon as you install the plugin, with no migration step. The reverse is also true. You can implement a feature in DSH, switch to Codex for a code review, and then ask Claude Code to write end-to-end tests. Each agent can pick up the decisions and progress left by the previous one.
New models and agent harnesses appear constantly. One day you may want to try a new state-of-the-art model; the next, a harness may ship a feature that fits your workflow. Switching tools should not mean abandoning the experience, knowledge, and project context you have already built up. With MemSearch, that history follows you.
There is one prerequisite: install the MemSearch integration for each agent you use. After that, you can move between supported agents without manually copying or synchronizing memory.
3. Helping the Agent Evolve
The third capability is the one we are most excited about, because it connects directly to DSH’s “everything is a plugin” architecture.
DSH exposes much more than a tool layer. Models, sessions, storage, orchestration, and even the agent loop that decides what happens next can all be replaced or recomposed as plugins.
Compare that with Claude Code. Its plugin system provides Skills, subagents, hooks, and related extensions around an established agent. DSH operates at a different layer: the harness that holds those components can itself be taken apart and reassembled.
| Dimension | Claude Code | DeepSeek Harness (DSH) |
|---|---|---|
| Product | Coding agent | Composable agent harness |
| Extension model | Adds extensions around the core agent loop | Everything is a plugin |
| Plugin scope | Skills, subagents, hooks, MCP | Models, tools, Skills, sessions, sandboxes, storage, agent loops, orchestration, UI |
| Agent loop | Part of Claude Code’s core harness | A replaceable plugin |
| Customization | Adds capabilities to an existing agent | Selects, replaces, and recomposes capabilities |
This is where “self-evolution” becomes concrete. When parts of the harness can be replaced, its capabilities no longer have to remain fixed at the factory defaults.
That is the ambition behind “everything is a plugin,” and it aligns closely with the direction of MemSearch.
Evolution Needs Fuel
Before an agent can evolve, it needs evidence.
It has to be used long enough to observe your habits and receive feedback from the environment. Without that history, it cannot know how it should change. It can only disguise guesses as improvements.
Organizing this history in the background is a core part of what MemSearch already does.
With the optional summarization features and scheduled jobs enabled, MemSearch periodically extracts two durable files from your project history: PROJECT.md, which records long-term project status, decisions, and risks; and USER.md, which records your preferences and development habits.
It can also identify recurring workflows in your long-term memory and distill them into candidate Skill files.
MemSearch organizes memory into three layers, each answering a different question:
| Layer | Question | Location |
|---|---|---|
| Episodic memory | What happened yesterday? | Logs in .memsearch/memory/*.md |
| Semantic memory | What remains true over time? | PROJECT.md and USER.md |
| Procedural memory | How should this task be done? | .memsearch/skill-candidates/ |
Many memory systems support the first two layers. The third is where MemSearch takes a different approach. We call it Memory to Skill.
Memory to Skill finds patterns that recur in memory and turns them into Skill files that follow the open Agent Skills standard.
Consider a release workflow. Every time you publish a version, you update the version number and changelog, run the build, and verify the installation in a clean environment. After that sequence appears five or six times in memory, Memory to Skill can distill it into a release Skill. The next time you say, “Publish a new version,” the agent can follow the workflow you have already established.
We deliberately keep a human in this process. New candidates remain in .memsearch/skill-candidates/ until someone reviews them.
Why not install them automatically? A distilled workflow may be wrong. It could contain a one-off workaround, hard-code a particular remote, or even capture a secret that should never become part of a permanent capability. Automatically promoting that material into the capability layer is more dangerous than saving an inaccurate note.
Skill Discovery
This review loop already works in other agents, but it depends on the user knowing the feature exists. You have to open the candidate directory yourself or remember to ask:
“Have any new Skills been distilled?”
That is easy to forget. DSH changes this part of the workflow.
Because DSH makes the UI extensible, the MemSearch plugin can add a Memory Dock directly to its web interface. The dock shows pending Skill candidates, where they came from, how often the pattern appeared, and actions to review or install them.
You no longer have to remember to look for new Skills. The Skills come to you. We call this Skill discovery.
Clicking Review does not interrupt the task currently running. The request enters the agent’s next turn, where it reads the candidate, checks its sources, and offers a recommendation for you to approve. Only after you click Install is the candidate copied into the Skills directory that DSH loads. The next time the same kind of task appears, the agent has a reusable procedure ready.
The result is a closed loop:
Memory provides the evidence. Repeated patterns become candidates. Candidates appear for review, and approved candidates become capabilities used in future work. New experience can then refine those capabilities over time. DSH makes the loop more visible and more natural.
This is what we mean by human-governed self-evolution.
The machine proposes; the human decides. Every new capability is reviewed before it becomes active.
We are still far from an agent autonomously rewriting its entire harness. But the direction is becoming clear. If every part of DSH is a plugin, the opportunity goes well beyond adding more Skills.
Today, the output is a reviewed Skill. Tomorrow, the same long-term feedback might help choose a preset, tune orchestration, or insert a review stage at the right point in a workflow.
This possibility is unique to DSH’s architecture, and it reflects the vision behind Cordis, the foundation of DSH’s Creator Mode.
At that point, memory no longer serves only as a record of the past. It begins to participate in each round of the agent’s improvement. The MemSearch plugin for DSH is a first step in that direction.