Preface

DeepSeek Harness (command: dsh) treats models, tools, sessions, and interfaces as plugins, with the official slogan “Everything is a plugin”. During the developer preview phase, the web interface already supports switching models and setting reasoning effort for models that support thinking. However, in actual use, the entry points are often split: switching models uses the native selector, and adjusting reasoning strength either requires typing /model or modifying settings.yaml. Users familiar with Codex will find this more noticeable—there you had a slider, but here you still have menus and commands.

The community plugin dsh-reasoning-effort combines these two functions into a control below the input box: when opened, there is a reasoning strength slider at the top, and the familiar model list below it. The档位 (effort levels) are not hardcoded to three options, but instead read the reasoning.efforts publicly exposed by the current model in the directory. This article is organized after cross-checking with the plugin directory page, GitHub README, v0.6.0 release notes, and DeepSeek Harness official documentation.

What is this

dsh-reasoning-effort is a model and provider plugin for the DeepSeek Harness web interface, maintained by HanaAyane, licensed under MIT, and primarily written in TypeScript. The community plugin directory categorizes it under “Models and Providers”, with an inclusion date of 2026-08-15; as of 2026-08-16, the GitHub repository has 52 stars and appears on the featured list of the directory’s homepage.

It solves a very specific problem: switching models and adjusting reasoning strength without modifying configuration or leaving the current session. The plugin is enabled by default, and reads and writes the same session model state as dsh’s built-in /model command. The current main branch and release tag are both 0.6.0, and the README indicates compatibility with DeepSeek Harness packages 0.1.0-rc.6, Node.js 22.19+, and React 18.x. The client platform is marked as web in package.json, with the slider attached to the web input area, not the terminal TUI.

When writing about the ecosystem background, two points need to be clarified. DeepSeek Harness is an agent framework open-sourced by DeepSeek, with its source code at deepseek-ai/deepseek-harness. deepseek-harness-plugin.com is an independent community directory for searching and installing third-party plugins, not officially affiliated with DeepSeek / HyperMind, and should not be treated as an official app store.

Core Features

Model and Strength Entry Below the Input Box

When the plugin is first opened, a new model entry will appear below the DSH input box, with the current model and current strength displayed simultaneously on the button. Clicking it opens a modal divided into two sections:
- The top section is the reasoning strength slider. Drag or click the track, and it will snap to the nearest valid level after releasing.
- The bottom section remains the DSH native model selection entry; click a model row to continue switching models.

The plugin is enabled by default. When not needed, you can turn off the “Reasoning Strength Slider” master switch in Settings → General Settings, and the native model selector will return immediately without uninstalling the plugin.

Effort Levels Follow the Model Exclusively

The levels displayed on the slider come from the reasoning.efforts publicly exposed by the current model in the DSH model directory—the number of levels, names, and order are all determined by the model (more accurately, the adapter directory), and the plugin only reads and automatically adapts. Starting from v0.5.0, models are no longer required to provide exactly three levels off / high / max; the release notes note that the core implementation of this version was contributed by Howardzhangdqs.

The README uses a common three-level combination as an example:

Level Suitable Scenarios Experience Orientation
off Simple Q&A, rewriting, quick operations Faster
high Daily programming, analysis, and multi-step tasks Balance of speed and reasoning
max Complex debugging, planning, and high-difficulty tasks More thorough reasoning

DeepSeek models typically expose off / high / max; GLM coding series (such as GLM-5.2) expose five levels off / low / medium / high / xhigh. The v0.5.0 release notes also mention GLM-5.3 (Low / High / Xhigh), GPT-5 (Minimal / Low / Medium / High), o3 / o4-mini, etc. As long as two or more levels are exposed in the directory, the slider will appear.

If there are fewer than two levels, or no levels are declared at all, the menu will display “The current model does not provide reasoning effort levels”. The slider only submits effort values already exposed by the model, and will not bypass the model or deployment’s capability limits; it will re-verify with the reloaded directory data before submission to avoid sending incorrect levels due to switching models during dragging.

Read-Only Guidance for Custom Providers

The levels of built-in routes come from the pi-ai directory, and the plugin does not modify them at all. Guidance will only be provided for models you declare yourself in the llm-pi-ai section of settings.yaml when levels are missing or declarations do not match the knowledge base. This capability was added in v0.6.0 (2026-08-16).

After opening the model menu, View Level Declaration Guidance will appear when conditions are met:
1. The panel provides recommended levels. When the knowledge base matches, for example, GLM-5.2 uses minimal / low / medium / high.
2. A complete copyable YAML entry (including the - id: line, with existing name, contextWindow, and maxTokens retained) and the path to settings.yaml are provided.
3. Replace the corresponding - id: entry entirely with this content (do not copy a second llm-pi-ai: root) and save. DSH will usually load it automatically; if it does not take effect, restart the Web Host and refresh the page.

The built-in knowledge base currently includes GLM-5.2 (minimal / low / medium / high) and Kimi K3 (low / high / max). Models not included in the knowledge base will receive a commented general template, which you can fill in values according to the endpoint documentation. When encountering situations such as “endpoint rejects request due to developer role”, the panel will issue a direct warning; the README gives an example: Alibaba Cloud Bailian OpenAI-compatible endpoints are recommended to use the built-in zai route instead.

The plugin only provides snippets, and will not modify any configuration for you; level collections in the built-in directory (even if only one level) will not be marked. The README also states that the plugin does not add telemetry, credential handling, or server-side storage.

Optional Fat Fish Slider

The default appearance upon first installation is a pure white button. To switch to an eight-frame running小人 (little figure), go to Settings → General Settings, enable Fat Fish Slider under the “Appearance” section, and return to the model entry. v0.4.0 integrated this appearance into the main branch, with it disabled by default.

The fat fish only replaces the button appearance, and does not change level snapping, keyboard controls, or model selection. It plays one cycle in approximately 720 ms when stationary, and speeds up to approximately 420 ms when dragging. If the system has “Reduce Motion” enabled, it will stop on a static frame. Both switches are only saved in the current browser.

Responsive Dragging, Themes, and Rollback

The README clearly defines the interaction boundaries:
- The button moves continuously according to the pointer position, and only snaps to valid levels after release, to eliminate dragging delay.
- The dark theme uses a blue-purple-black gradient, and the light theme uses a blue-white gradient, with deeper blue for higher strength levels.
- Waves, shockwaves, pixel radiation, particles, and trails only appear on the left side of the button, and will not cross over the button.
- Update failures will revert to the last confirmed level.

Installation and Activation

The installation command given on the community directory page is:

dsh plugin add github:HanaAyane/dsh-reasoning-effort

Run this in the DeepSeek Harness terminal. The directory page also reminds users that the plugin runs with the permissions of the current dsh process, and may execute code during installation; you should check the source code repository and license before installing. For a reproducible installation, pin the commit hash.

The repository README is targeted at the Web Profile, and recommends two commands (available in PowerShell / terminal):

dsh plugin --profile web add github:HanaAyane/dsh-reasoning-effort#main
dsh --profile web --dump-config

#main always installs the latest code, which may include unreleased changes in the future. The current main branch is 0.6.0, matching the v0.6.0 tag. To pin to this version, change #main to #v0.6.0:

dsh plugin --profile web add github:HanaAyane/dsh-reasoning-effort#v0.6.0

To pin to the commit verified in this article, use the directory page’s command:

dsh plugin add github:HanaAyane/dsh-reasoning-effort#f94622b46078ac8c064f91bdc10ab27e8cf32270

The plugin loads when the Web Host starts. After running the installation command, terminate the current Host and restart it, then refresh the DSH page. Do not let the Agent shut down the running Host for you. To confirm whether it has loaded:

dsh --profile web --dump-config

name: dsh-reasoning-effort should appear in the output. To uninstall:

dsh plugin --profile web remove dsh-reasoning-effort

After uninstalling, restart the Web Host again, and the native model selector will automatically restore.

Typical Usage

Opening the Slider for the First Time

  1. Create or open a session.
  2. Click the button below the input box that displays “Model + Current Strength”.
  3. Drag the slider or click the track, and it will snap to the nearest level after releasing.
  4. Click the model row below the slider to enter the DSH native model list.

Afterwards, using /model to change the model and strength will sync with the slider, because both read and write the same session model directory.

Adding Levels for Custom Models

When a model is not in the pi-ai built-in directory (the README uses GLM-5.3 as an example), the menu will prompt that no levels are provided. You can paste the guidance snippet, or declare it manually in ~/.dsh/settings.yaml. The zai coding route example from the repository documentation is as follows:

llm-pi-ai:
  providers:
    zai-coding-cn:
      models:
        - id: glm-5.3
          name: GLM-5.3
          contextWindow: 1000000
          maxTokens: 131072
          reasoningEfforts:   # Key = level name displayed on the slider, Value = actual reasoning_effort sent to the API
            low: "low"
            high: "high"
            xhigh: "max"
          compat:             # The zai route does not send reasoning_effort by default, needs explicit enabling
            thinkingFormat: "zai"
            supportsReasoningEffort: true

A few constraints from the README:
- Use the DSH system for level names (off / minimal / low / medium / high / xhigh), and the value is the reasoning_effort actually accepted by the endpoint; off is not optional if not declared, suitable for models that cannot disable thinking.
- Models already included in the pi-ai directory (such as GLM-5.2) will automatically inherit the levels, and do not need to be written manually.
- Once the upstream directory includes the model, the handwritten declaration can be deleted; handwritten entries always take priority over the directory.
- The final value is verified and sent by the host, and the plugin will not bypass restrictions.

To add entries to the plugin’s own knowledge base, write them under its namespace, with user entries taking priority over built-in ones:

dsh-reasoning-effort:
  entries:
    - id: my-model
      provider: "*"          # Provider route name, * for wildcard
      model: "my-model-id"   # Model ID, * for wildcard
      note: Description text
      efforts:               # Level name → actual value accepted by the endpoint
        low: "low"
        high: "high"
        max: "max"
      compat:                # Only required for openai-completions routes
        thinkingFormat: "openai"
        supportsReasoningEffort: true

Slider Not Visible After Installation

Confirm in the following order according to the README:
1. You have restarted the DSH Web Host after installation.
2. Settings → General Settings → Reasoning Strength Slider is enabled.
3. The current model exposes at least two reasoning effort levels in the directory, and the deployment has not disabled thinking. For models that do not declare levels, add the declaration using the previous section’s method.

Applicable Scenarios and Notes

This plugin is suitable for users who frequently switch models and adjust reasoning strength according to tasks in the DSH web interface, especially those who have connected custom providers (self-built gateways, third-party compatible endpoints) but found that the slider does not appear. Use low levels for daily Q&A and high levels for complex debugging, without needing to modify YAML first. If you only run dsh in the terminal profile and do not use the Web UI, this client-side control will not be useful.

Before using, pay attention to these verified boundaries:
- The plugin runs with the permissions of the current dsh process, and may execute build scripts during installation. Check the GitHub repository and MIT license before installing; pin the tag or commit in production environments.
- The client platform is web. The RPC for level guidance is only attached to the Web profile.
- DeepSeek Harness is still in developer preview, and upstream UI or service changes may require the plugin to be updated synchronously. The current target version is 0.1.0-rc.6.
- The slider cannot “invent” thinking capabilities for the model. If no levels are in the directory or the deployment has disabled thinking, no draggable levels will appear in the interface.
- The plugin does not modify the built-in directory, write to settings.yaml, or add telemetry or credential handling. You need to paste custom level declarations yourself.

Summary

dsh-reasoning-effort brings the Codex-style “Model + Reasoning Strength” control to below the DeepSeek Harness input box: the levels follow the model directory, sync with /model, and roll back on failure. v0.6.0 added read-only YAML guidance for custom providers, and still does not modify configuration for you. The community directory installation command and repository addresses are as follows; check the source code and license before installing.

  • Directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-reasoning-effort/
  • GitHub: https://github.com/HanaAyane/dsh-reasoning-effort
  • Current release: https://github.com/HanaAyane/dsh-reasoning-effort/releases/tag/v0.6.0