Foreword

Developers who have used DeepSeek Harness (DSH) have probably all encountered this kind of awkward situation: the architectural agreements established with the AI yesterday are completely forgotten when starting a new session today; while maintaining two or three projects simultaneously, to-do items and decisions are scattered across different conversations, and picking them up again requires recounting everything from scratch. The official DSH breaks down capabilities into a plugin ecosystem, and there are many “memory” plugins in the community. However, stringing together cross-session memory, to-do management, skill accumulation, multi-session collaboration, and external AI scheduling into a single pipeline often requires installing several packages.

Today, we introduce dsh-memory-evolve (maintained by csyangwen), which takes a different approach: a pure plugin with zero core modifications and zero runtime dependencies, integrating capabilities such as “cross-session long-term memory + backend self-evolution” and collaboration scheduling into a single package as much as possible. The project has garnered approximately 240+ stars on GitHub (as of 2026-08-25), is categorized under “Memory,” and can be found in both the SkillHub Plugin Library and the GitHub repository. It is important to note that community directories like SkillHub are maintained by the community and have no official affiliation with DeepSeek / High-Flyer. DSH itself adheres to the philosophy of “everything is a plugin.”

What is this

dsh-memory-evolve is a memory and collaboration enhancement plugin for DeepSeek Harness. It does not modify the DSH core; after installation, it automatically registers with the host via the included cordis.patch.yml (dsh.bundle.patch declaration), and its effects are cleaned up upon uninstallation.

In a nutshell: It gives the AI in DSH cross-session long-term working memory and, based on that, enables it to manage to-do items, accumulate skills, orchestrate multi-session and external AI agent collaboration—switching sessions doesn’t lose context, and it becomes more attuned to your workflow the more you use it.

Core Features and Highlights

The plugin’s README is organized around real-world workflows, covering a broad range of capabilities. Below, the main modules are summarized based on verified information.

Five-Track Memory and Git Branch Awareness

Memory is divided into multiple tracks, each with its own function:

  • User Profile: Preferences, company, communication habits, etc., can be injected into the context each round.
  • Global Facts: Long-term knowledge such as environments, tools, and conventions.
  • Project Key Memory: Agreements, decisions, and architecture for the current project, which can be marked to apply only on a specific git branch.
  • Project Log / Daily Log: Automatically records progress each round, with traceable history.

Important write operations require your confirmation before taking effect, preventing the AI from modifying memory arbitrarily. Project logs also include branch markers like [git main] for easy tracing.

Four-Track To-Do Management

Four to-do tracks: Life, Work, Project, and Daily. The Project track is isolated by working directory, so switching directories doesn’t interfere. Telling the AI, “Remember, deploy the secondary panel by Friday,” creates a to-do with a deadline and importance/urgency markers. At the end of the day, the AI will remind you of due items.

Skill Self-Evolution and Skill Manager

Methodologies from repeated pitfalls can be solidified into skills, allowing similar tasks to be executed according to a process next time. Within the Memory tab, you can browse, search, disable, and edit all skills, and add custom skill directories. The previously independent plugin dsh-skills-manager has been merged into this plugin; old users must uninstall the old plugin before upgrading.

COI Scheduling and Session Broadcasting

COI Scheduling can asynchronously delegate heavy tasks to external AI agents (such as Kimi, Codex, Grok, Hermes, etc.) without blocking the current session; upon completion, summaries are written to the project log. Session Broadcasting supports initiating multiple sub-sessions within a collaborative room (for design, frontend, backend, testing, etc.), with visible member statuses and the ability for the main session to wake up idle sessions to continue task assignment.

The Prompt Library can solidify work methods like code review checklists and PRD specifications into injectable instruction paradigms, which the AI can choose autonomously or you can inject with one click. Session Search allows the AI to search for historical sessions from other AI tools on your machine (such as Codex), reducing the effort of recalling “where was this discussed before.”

In-Round Memory Review and Other Capabilities

Every N user rounds, the AI can proactively extract noteworthy information for your confirmation (disabled by default; must be enabled in configuration). Additional capabilities include session bookmarks and arbitrary branching, infinite canvas, session review (Advisor), memory synchronization (multi-device sharing of project memories), channel notifications, and more; most advanced modules are disabled by default and can be enabled as needed in the “Memory Evolve Settings” to avoid cluttering the AI tool list.

The plugin adheres to three principles: AI proposes, you confirm; it doesn’t recreate wheels that already exist officially; internal sessions handle tasks requiring context, while external agents handle one-off heavy tasks, all connected into a pipeline by memory, rooms, and prompts.

Installation and Activation

Using the common web profile as an example, the installation method provided in the official README is as follows:

# 1. Install to the profile (use link: for local development or git package address)
dsh plugin --profile web add github:csyangwen/dsh-memory-evolve

# 2. Restart dsh web to take effect

Note: Do not manually insert this plugin into ~/.dsh/profiles/web/cordis.patch.yml. The bundle is automatically registered, and duplicate insertions with the same ID will cause a “duplicate loader entry id” error, preventing DSH from starting. If upgrading from an older version and you previously manually inserted, please delete the insert line from the profile patch.

To enable in-round memory review, you can override with the ID in the profile’s cordis.patch.yml (top-level declaration, not insert):

- id: dsh-memory-evolve
  config:
    reviewEnabled: true      # Enable in-round memory review (default off)
    reviewInterval: 10       # Review every 10 user rounds

If the plugin causes DSH to fail to start, you can temporarily disable it without uninstalling:

- id: dsh-memory-evolve
  disabled: true

Uninstallation command:

dsh plugin --profile web remove dsh-memory-evolve

License is MIT (as per the GitHub repository).

Typical Usage Examples

After installing the plugin and restarting, the Web UI will display capability tabs for Memory, Skills, To-Do, COI Scheduling, Prompts, etc. The following scenarios are taken directly from the official documentation and can be reproduced.

1. Writing and Querying Long-Term Memory

Normal conversation suffices; project logs and daily logs are automatically written at the end of each round. When an important fact is discovered, say:

Note: The deployment port for this project is 8080

The AI will write to the Project Key Memory, which takes effect only after your confirmation. A few days later, in a new session, ask “Check the memory, what was the architectural decision we made last time?” to pick up the context.

2. Multi-Project To-Do Items Don’t Get Mixed Up

Start chatting in a new project directory; project logs and to-do items are automatically isolated by directory. Tell the AI, “Remember, complete the API integration by Friday,” and the to-do enters the pending queue, where you can accept or reject it in the “To-Do” tab.

3. Coordinating Multiple Internal Sessions

To the main session, say:

Create 4 sessions: design for website visuals, frontend for pages, backend for APIs, and testing for acceptance, and pull them into the same collaborative room

The main session will create sub-sessions and pull them into the room; you can ask “Who is working now, who is idle?” and then assign tasks to idle sessions. The DSH process hosting the main session must remain running for the wake-up chain to persist.

4. Delegating Heavy Tasks to External Agents

Tell the AI:

Assign this task to grok: mobile adaptation renovation

The backend executes asynchronously and returns a task ID; during execution, you can ask for progress or view logs in “COI Scheduling”; upon completion, a summary is automatically written to the project log.

5. Multi-Device Memory Synchronization (Optional)

Enable the memory synchronization module in “Memory Evolve Settings → Configuration,” open “Project Synchronization” in the project session’s “Memory Synchronization” tab, and push; another computer can pull the memory after cloning the same repository. For public code repositories requiring private memory, you can configure a separate shared memory repository address.

Applicable Scenarios and Considerations

Who is this for:

  • Long-term DSH users for project development who want the AI to remember preferences, decisions, and pitfall records.
  • Those maintaining multiple repositories who need to isolate memory and to-do items by directory.
  • Those who want to treat the AI as a “small team” or delegate heavy tasks like visual revisions and code reviews to external CLI agents.
  • Those sensitive to context length who need bookmarks, branches, canvas, and other methods to manage long sessions.

Considerations:

  1. Permissions and Security: The plugin runs with the current dsh process permissions, allowing read/write access to workspace files and invocation of configured external CLIs. Please read the source code and MIT license before installation to ensure it meets your security policies.
  2. Primarily for Web: The dsh.client.platform in package.json is set to web, and capabilities are designed around the Web UI; for CLI scenarios, please refer to the README.
  3. Modules Disabled by Default: Session review, infinite canvas, notifications, etc., need to be manually enabled to avoid cluttering the tool list.
  4. Community Directory: The installation commands in this article are based on the GitHub README; SkillHub serves as the discovery portal, and page information may slightly lag behind the repository; in case of conflicts, the repository documentation takes precedence.
  5. Migration from Old Plugins: If you previously installed dsh-skills-manager separately, please uninstall the old plugin before upgrading to this one.

Summary

If you want the AI in DSH to transform from “amnesiac every session” into a partner that can remember the project’s full scope, manage to-do items, and initiate internal-external collaboration, dsh-memory-evolve is worth trying. It integrates memory, evolution, and scheduling into a plugin with zero runtime dependencies, ready to use upon installation and cleanly removed upon uninstallation, aligning with DSH’s “everything is a plugin” extension philosophy.