Preface¶

When using DeepSeek Harness for research-related tasks, the common breaking point is not “whether you can find a paper”, but rather how to connect retrieval, solutions, experiments, and conclusions afterward. You summarize several papers in a conversation, but the experiment scripts are in another directory; the model gives accuracy figures but cannot clarify which run they came from, which dataset and random seed were used; halfway through writing the manuscript, the project status no longer matches. Agent loops are ideal for advancing these steps, but without recoverable project state and human checkpoints, conclusions can easily turn into unreviewable chat logs.

DeepSeek Harness (hereinafter referred to as DSH) takes “everything is a plugin” as its architectural principle: models, tools, sessions, and interfaces can all be replaced or superimposed. The dsh-scholar in the community directory follows this path, integrating literature research, subsequent controlled experiments, evidence ledgers, and TeX manuscripts into the same recoverable project. The directory page categorizes it under the “Memory” category, and the short introduction emphasizes “directly retrieving, reading, and summarizing literature in an agent loop”; the repository README frames it as an AI research workbench for pure computational research. The two are not contradictory: literature retrieval is just one segment, and project-level state is what it truly aims to remember.

This article is organized after cross-checking with the community directory page, GitHub repository README/Chinese instructions, host integration documentation, and package.json: what this plugin is, what it can currently do, how to install it, the typical workflow, and its usage boundaries. The community plugin directory is an independent site and has no official affiliation with DeepSeek/Hugging Face. Do not treat it as an official app store.

What It Is¶

dsh-scholar (product name DSH Scholar) is a community open-source plugin maintained by lzszq, hosted on the GitHub repository lzszq/dsh-scholar under the MIT license. The primary language is TypeScript. The root package name is @dsh-scholar/research-plugin, with the current version number 0.1.0, marked private: true, and the @dsh-scholar/* packages have not been published to the public npm registry. The GitHub repository has the topics dsh and dsh-plugin; as of the check on 2026-08-17, the repository had 20 stars, while the community directory page still showed 15 stars.

Its goal is not to build another standalone paper search box, but to integrate the following content into the same recoverable project:
- Research materials and literature snapshots
- Project conversations
- Code and data
- Experiment runs
- Evidence ledgers
- TeX manuscripts

You can start with a new research question, or pick up an ongoing research project. The default governance mode is gate-only: the Agent cannot approve Human Gates, forge accepted Evidence, or bypass experiment contracts. The repository README clearly states “urgent development and adaptation are in progress”, and the Chinese README provides the installation compatibility verification baseline as @deepseek-ai/dsh@0.1.0-rc.6.

Core Features¶

Literature Retrieval Is Just the First Step¶

The short introduction on the community directory positions it as an academic paper search and understanding plugin. The corresponding capabilities in the repository are the Scholar/Curator group: literature_search, paper_resolve, corpus_snapshot, passage_lookup. The description of @dsh-scholar/scholar-connectors is controlled academic connectors, covering OpenAlex, Crossref, arXiv, with caching, deduplication, and immutable query snapshots. You can use /survey in Chat for literature research; the research itself is not a Runner Job, and after successful completion, it will submit a Corpus Snapshot, and the project enters the research-ready state, with generating Ideas being the next step.

In other words, retrieving, parsing papers, and freezing corpus snapshots are the inputs for subsequent Idea Gates and experiment contracts, not the entirety of the plugin.

Research Workflow with Human Gates¶

The typical stages given in the README are:

Create/access project → Grill Me → Scope Gate → Literature research → Idea Gate
→ Baseline → Experiment Contract → Experiment run → Evidence and Claim
→ TeX writing and review → Private export → Release Gate

Key nodes are reviewed by human Gates, covering Scope, Idea, Experiment Contract, then Evidence, Claim, and Release. The Research Kernel saves authoritative state, NextAction, approval trails, and product references. Both Overview and Chat read this authoritative next step, explaining the reason, executor, and blocking items.

There are three ways to enter the workbench:
1. Init: Fill in the project name, use Grill Me in Chat to complete the research Brief, and confirm to create the Scope Gate.
2. Resume: Open an existing project to restore stages, sessions, files, and tasks.
3. Upload: Upload papers, code, data, or logs. Uploaded content first enters the isolated Intake and will not automatically become Evidence.

Controlled Experiments and Traceable Evidence¶

Formal experiments must be bound to immutable code/data snapshots and a fixed execution environment, executed by a controlled Runner. The Runner can run on the local Docker or on a controlled remote machine, and logs, status, and products will be recorded. Without a Runner, you can still manage projects and files, but experiment Jobs will remain queued.

Paper claims must be traceable to controlled Runs, Artifacts, and reviewed Evidence. Outputs from Chat, regular stdout, and Interactive Terminal will not automatically become formal Evidence. The repository uses cnn-mnist-digits to demonstrate this workflow: the research question is “Does a dual-convolutional CNN with per-channel normalization achieve higher accuracy than a single-convolutional CNN baseline?”; the data and metrics are mnist_subset_v1 / test_accuracy; random seeds 11 / 23 / 47; the result in the documentation is test_accuracy = 96.8%, +4.4 percentage points relative to the baseline, with a bootstrap 95% mean difference confidence interval [1.2, 8.6] (n=3). This is an example from the repository documentation, not tested in this article.

All-in-One Workbench¶

Chat, Workspace, Terminal, Manuscript, Trajectory, and Settings share the same project context. The plugin provides Agent tools, slash commands, Skills, configuration cards, and a dsh Scholar tab to DSH; the tab reuses the launched standalone workbench without building a separate business UI. DSH and the standalone workbench share the Research Kernel at 127.0.0.1:7412 and the ~/.dsh/research-kernel data directory, so both sides operate on the same projects. Browser tokens, sessions, and display preferences are still stored separately in the standalone workbench’s BFF directory.

The plugin also includes four source Skills: research-core, domain-machine-learning, domain-data-science, venue-templates. Domain and conference templates are injected based on the domain and target_venue of the project Brief, instead of expecting the model to look up documents on its own.

Installation and Activation¶

The installation command given on the community directory page is:

dsh plugin add github:lzszq/dsh-scholar

For reproducible installation, fix the commit hash according to the directory page instructions:

dsh plugin add github:lzszq/dsh-scholar#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 check the source code repository and license before installing.

The current repository instructions are more detailed: @dsh-scholar/* has not been released yet. For full integration, it is recommended to build from the local repository and add the absolute path to DSH’s web profile. Local experience requires Linux, Node.js 24, pnpm 11.20.0; formal experiments, TeX compilation, and clean-room reproduction also require Docker Engine.

First install and build in this repository:

pnpm install --frozen-lockfile
pnpm run build

To run only the standalone workbench without connecting to the DSH Agent:

bash scripts/start-standalone-ui.sh

The default page is http://127.0.0.1:18610/. When opening it for the first time, paste the content of this access token file with permissions 0600:

~/.dsh-scholar-standalone/research-ui-standalone/standalone-token

The standalone workbench does not require DSH, but will not include Agent tools, slash commands, Skills, configuration cards, and the dsh Scholar tab. To obtain full integration, the repository recommends installing and building the latest DSH source code with pnpm, then running DSH from that source repository, then adding the absolute path of the Scholar repository to the web profile:

cd /path/to/dsh-source
pnpm install
pnpm run build
pnpm dsh plugin --profile web add /absolute/path/to/dsh-scholar
pnpm dsh plugin --profile web why @dsh-scholar/research-plugin
pnpm dsh web

Here, /path/to/dsh-source is the latest DSH source code repository, and /absolute/path/to/dsh-scholar is this repository. When updating, first re-run pnpm run build in the Scholar repository, then execute the same add command. To uninstall:

pnpm dsh plugin --profile web remove @dsh-scholar/research-plugin

If you need to run experiments in the local Docker, start the Runner in another terminal:

export DSH_SCHOLAR_KERNEL_TOKEN="$(< ~/.dsh/research-kernel/kernel-token)"
export DSH_SCHOLAR_SERVICE_TOKEN="$(< ~/.dsh/research-kernel/service-token)"
node workers/runner-gateway/lib/bin/runner.js \
  --kernel http://127.0.0.1:7412 \
  --mode docker

After installing the plugin, open Settings → Plugin Configuration → dsh Scholar in DSH. Saved changes will take effect after the next restart of DSH. The configuration items in the documentation are as follows:

The Standalone Address does not allow credentials, query parameters, or URL fragments, and tokens should not be placed in the URL. If DSH Web is not running on the default local port 3080, use the DSH_SCHOLAR_STANDALONE_FRAME_ANCESTORS configuration before starting the standalone workbench to allow the exact origin for embedding.

Typical Usage¶

Please refer to the repository README and User Guide. In DSH Chat, you can directly say “Create research project …”, “Continue research”, “Where are we now”; Harness will go through Scholar’s controlled session entry dsh_scholar. When there is no associated project, a full creation instruction with the complete project name from the original text will create a name-only Init and bind the current session; if the name is missing, it will prompt for it. Gates, Brief confirmation, external material adoption, and release decisions still need to be completed by humans.

Chat also supports first-level slash commands. The commonly used commands listed in the README are:

/new  /status  /survey  /ideas  /gates  /contract  /run
/evidence  /claims  /write  /review  /release-bundle  /release

The user guide also includes /list, /jobs, /reproduce, /help. DSH Web already occupies /export for downloading Session logs, so Scholar uses /release-bundle to generate private release packages. Do not add an additional aggregation prefix to these commands.

A minimal reproducible path according to the documentation:
1. Start the standalone workbench, start the Runner if necessary, and add the plugin to the DSH web profile as in the previous section.
2. Create a project in natural language, or execute /new project-name. Answer the Grill questions in Chat, and the Scope Gate will appear after confirming the Brief.
3. After Scope approval, execute /survey "your research question". Check if the Corpus Snapshot has been submitted, then execute /ideas.
4. After selecting the Idea and completing the Idea Gate, register code and data snapshots, and submit the Baseline and Experiment Contract.
5. Use /run to run the formal control experiment; view read-only logs in the Run Terminal. Use the Interactive Terminal for interactive debugging, but its output will not automatically become Evidence.
6. Use /evidence and /claims to bind metrics, effect sizes, confidence intervals, and Runs/Artifacts to claims, and mark them as accepted only after review.
7. Edit paper.tex and main.bib in Manuscript, use /write and /review to advance the manuscript; approve the Release Gate before public release.

cnn-mnist-digits is a documented example of this path: Chat advances the task, Gates lock the scope and contract, baseline and formal solutions are executed as independent Jobs, failed records are retained and can be retried, and finally evidence is written into the manuscript.

Applicable Scenarios and Notes¶

It is suitable for people who use DSH as a research host and need project-level state rather than one-time Q&A. The repository limits the product scope to pure computational research such as machine learning, data science, and bioinformatics. It can be used for literature research, controlled controlled experiments, tracing claims to Runs/Artifacts, and writing manuscripts in a fixed TeX Live environment.

The following boundaries are clearly stated in the documentation, do not relax them on your own:
- DSH Scholar assists research, and does not replace researchers in undertaking scientific judgment, approval, authorship, and release responsibilities.
- The default mode is gate-only. The Agent cannot approve Human Gates, and cannot directly convert Chat or terminal output into formal Evidence.
- Not applicable to clinical decision-making, human trials, wet experiments, or other high-risk research.
- The user guide states that the product is still under development; capabilities should only be applied to formal research after they are marked as “accepted” in the repository’s hardening status documentation and bound to the current CI evidence.
- The plugin runs with the permissions of the current dsh process. Check the source code repository and MIT license before installing; in production environments, prioritize fixing the commit hash instead of tracking the floating default branch.
- The standalone workbench’s access token, Kernel token, and Runner token are local secrets; do not put them in URLs or commit them to the repository.

Summary¶

dsh-scholar connects literature retrieval to DSH’s agent loop, while using the Research Kernel to remember project stages, approvals, and products. The directory page shows it as a “Memory” category plugin with a paper search introduction; when you open the repository, it is more like a computational research workbench with human checkpoints. It is still undergoing urgent adaptation to DSH, and full integration requires local building, and you cannot understand it as a released npm package.

Community Directory Page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-scholar/

GitHub Repository: https://github.com/lzszq/dsh-scholar