Preface¶

When using agents to create landing pages, UI drafts or previewable prototypes, the common practice is to directly ask the model to write the first version, then revise it repeatedly on the same result. Once the direction is fixed, all subsequent revisions are stacked on the same thread. To compare several clearly different options side by side, you can only open new sessions, copy and paste manually, and compare them based on memory.

DeepSeek Harness (dsh) has packaged this capability into a plugin: the official repository positions itself as “everything is a plugin”, open-sourced by DeepSeek AI. It is currently in developer preview, and the interface may change incompatibly. The community site DeepSeek Harness Plugin Repository will host third-party plugins, which is an independent directory and has no official affiliation with DeepSeek / Fangzhou.

dsh-ramify is a tool and capability plugin in this directory. It embeds a tree canvas in the DSH web interface, organizing multiple creative directions, runnable works and subsequent revisions into a real-time updated creative tree for generation, comparison and continued branching.

This article is organized after cross-checking with the plugin directory page, GitHub repository README, package.json and source code: what it is, how to install it, how to use it, and the boundaries to pay attention to during use.

What it is¶

dsh-ramify is a dsh-plugin specifically written for DeepSeek Harness, with the package name @ramify/dsh-ramify and current version 0.1.0. The GitHub repository is yanglongyun/dsh-ramify. The directory page lists the maintainer as yanglongyun, and the license is MIT (the copyright statement in LICENSE is Copyright (c) 2026 Sider AI). The main language of the repository is TypeScript, and GitHub currently shows 9 stars.

The problem it solves is very specific: after the agent gives multiple directions at once, the results are still scattered in the chat history, which is neither visually clear, easy to compare, nor convenient to continue revising from a specific node. Ramify organizes these results into nodes on the canvas, retains old solutions, and grows new revisions as child nodes.

The plugin follows the DSH standard plugin manifest, Cordis services and Client UI slots, and does not modify the Harness source code. The dsh.client.platform field in package.json is declared as web, so the interface appears in the web sidebar and overlay, not a terminal TUI plugin.

Core Features¶

Tree Canvas Instead of a Single Chat Thread¶

The README outlines the workflow in five steps:
1. Click Ramify in the left sidebar of DSH to open the built-in workspace.
2. Fill in the requirements in the Ramify native input box and select the number of solutions to generate.
3. The plugin first creates a project and immediately enters the canvas, while submitting the task to the current DSH session and model.
4. The agent continuously writes solutions to the canvas via the Ramify tool, and nodes and previews will appear in real time.
5. Click the expand button in the upper right corner of a node, enter the modification requirements, and you can continue to generate branches from that node.

You do not need to copy the local address during the process, nor do you need to reconfigure the model or API Key in Ramify. The interface submission uses the official session input capability of DSH, and the model call is still handled by the current session.

You can also directly ask the agent to use Ramify in the DSH chat without clicking the input box. An example given in the README is:

Use Ramify to explore three distinctly different landing page directions for this AI search product, and create previewable pages for me to compare.

Work Types and Previews¶

Nodes are not just text. The source code divides cards into title, note and work categories; work types include HTML, Markdown, SVG, images, videos and audio. The README states that these works can be previewed directly on the canvas.

There are two layers of previews with different behaviors:
- The canvas card thumbnails use an empty sandbox and will not run JavaScript to avoid slowing down the canvas when a large number of scripts are executed simultaneously.
- The right-side details and works opened in a new window do not use sandbox or CSP, and can run scripts normally, load external resources, connect to the Internet and submit forms.

In other words, the detail page is closer to a “normal web page” rather than a sandbox demo.

Local Runtime and Persistence¶

The architecture is divided into two parts: the Ramify overlay (iframe) in the DSH web page, and the local Ramify runtime. The default addresses given in the README are:
- DSH Web UI: http://127.0.0.1:3099 (this is the sample port in the plugin README; the official Harness documentation says npx @deepseek-ai/dsh web defaults to port 3080)
- Ramify runtime: http://127.0.0.1:9519

The plugin will launch the packaged runtime when started. In the source code src/runtime.ts, the subprocess environment variables HOST are set to 0.0.0.0, and PORT defaults to 9519; the plugin itself uses http://127.0.0.1:9519 for health checks and API calls. If there is already a healthy Ramify instance on that port, it will be reused instead of starting another one. When the plugin is uninstalled, only the processes it started will be cleaned up.

Projects, nodes and works are saved using SQLite and local artifact files. When dataDir is omitted, the system’s application data directory is used:
- macOS: ~/Library/Application Support/Ramify/
- Windows: %APPDATA%/Ramify/
- Linux: ${XDG_DATA_HOME:-~/.local/share}/ramify/

Upgrades or restarts will not clear data by default. The frontend uses lightweight polling to perceive changes.

Tools Registered for the Model¶

The plugin registers a set of tools to the current model, with names and purposes based on the README:

In the source code, the theme values for ramify_settings are light / dark / system, and the language values are system / zh-CN / en / ja / es / de. ramify_node_batch can create up to 100 cards at a time. The system prompt requires that revisions with comparative value should be made as child nodes instead of overwriting old solutions; do not treat loopback service addresses as the main result for users, and the main interface is the workspace in the DSH sidebar.

Installation and Activation¶

The environment requirements come from the README:
- Node.js 22.19 or higher
- DeepSeek Harness 0.1.0-rc.6 (the current tested version listed in the repository) or compatible version

The installation command given on the community directory page is:

dsh plugin add github:yanglongyun/dsh-ramify

For reproducible installations, the directory page recommends pinning the commit hash:

dsh plugin add github:yanglongyun/dsh-ramify#commit

Replace #commit with the actual commit hash. The plugin runs with the permissions of the current dsh process, and may execute code during installation. You should inspect the source repository and license before installing.

Since the client declares itself as web, the repository README recommends installing it into the web profile. First clone and add it locally:

git clone https://github.com/yanglongyun/dsh-ramify.git
cd dsh-ramify
npm install
npm run build

dsh plugin --profile web add "$PWD"
dsh web --port 3099

The README also states that lib/ and app/dist/ will be committed to the repository, so you do not need to run the build script during installation when checking out locally or installing via Git. The npm run build command above is for source code development; if you only install according to the github: specification on the directory page, you will use the built artifacts already committed in the repository.

There is also a section “After npm Package Publishing” in the README:

dsh plugin --profile web add @ramify/dsh-ramify

As of the time of this article’s verification, the npm registry does not yet have the @ramify/dsh-ramify package (returns 404), so do not treat this as a usable installation method at this time.

After starting, click Ramify at the bottom of the DSH left sidebar. The plugin will automatically start the runtime and embed the workspace into the DSH overlay; the external open button at the top is only an optional independent window.

To change the port or data directory, you can override it in the profile’s cordis.patch.yml. The default patch included in the repository is:

- insert:
  - id: ramify
    name: '@ramify/dsh-ramify'
    config:
      port: 9519
      startupTimeoutMs: 5000
      shutdownTimeoutMs: 3000

The README also allows adding dataDir, which must be written as an absolute path.

Typical Usage¶

After installing and opening the Web UI, there are two entry points.

The first is Ramify’s own input box: clarify the requirements, select the number of solutions, submit and then enter the canvas to wait for the nodes to grow. When you like a certain version, you can branch out from that node, and the old node will remain unchanged.

The second is to directly give instructions in the current DSH session and let the agent call the Ramify tools. You can follow the landing page example in the README, or replace it with UI drafts, Markdown documents or SVG. The agent will first run ramify_project_create, then add nodes to the tree according to the card type; works can be placeholders first, and then use ramify_node_complete to write HTML / Markdown / SVG / media into them.

The canvas does not need to refresh the chat to update. The frontend polls the local runtime, and nodes and previews will appear as the API writes data.

Applicable Scenarios and Notes¶

It is suitable for these situations:
- You need to view multiple visual or structural directions at the same time, instead of revising back and forth on the same draft
- The works themselves can be previewed in a browser (HTML, Markdown, SVG, images, audio and video)
- You are already using the DSH Web UI and want to reuse the current session and model without reconfiguring a set of API Keys

The boundaries to note:
1. This is a community plugin, not an “official certified extension” in the official app store. The directory site has no official affiliation with DeepSeek / Fangzhou. Harness itself is still in developer preview.
2. Permissions and installation security. The plugin runs with the permissions of the current dsh process, and installation may execute code. Read the source code and MIT license before installing; pin the commit when reproducibility is required.
3. Only covers the Web client. dsh.client.platform is web, and the sidebar entry appears in the web interface. The official default Web port is 3080, and the plugin README uses 3099 as an example, please refer to your actual startup command.
4. Runtime listening address. The source code sets the subprocess HOST to 0.0.0.0, and the DSH sidebar uses 127.0.0.1:9519 to access. If your local network environment is sensitive, you should be aware of this and do not assume that the service is only bound to the loopback.
5. No sandbox for detail pages. Thumbnails do not run JS; the right-side details and new windows execute as normal web pages, and can run scripts, connect to the Internet and submit forms. Do not casually open the details when the preview source is untrusted.
6. Does not save model keys, but persists works. The plugin does not read, receive or save model API Keys; project data is written to the system application data directory by default, and uninstalling the plugin does not necessarily delete these files.
7. The npm package has not been published yet. Currently you should install from GitHub source code or the directory page’s github:yanglongyun/dsh-ramify, do not install the non-existent registry package.

Summary¶

dsh-ramify turns “generate multiple previewable solutions at once and continue branching from the nodes you like” into a native canvas in the DSH web interface. It reuses the current session and model, uses SQLite to keep tree revisions locally, and old solutions will not be overwritten by new revisions.

The project is still in its early version (0.1.0), and the test baseline is Harness 0.1.0-rc.6. If this workflow is exactly what you are missing, you can evaluate it from the directory page or the repository before installing.

• Directory page: https://deepseek-harness-plugin.com/en-US/plugins/dsh-ramify/
• GitHub: https://github.com/yanglongyun/dsh-ramify
• DeepSeek Harness: https://github.com/deepseek-ai/deepseek-harness