Preface¶

DeepSeek Harness (dsh) is an agent runtime open-sourced by DeepSeek, whose official repository positions itself as “everything is a plugin”: tools, interfaces, and model adapters can all be hooked into the same Cordis runtime as external add-ons. It is currently in the developer preview stage with rapid iterations, and breaking compatibility changes are expected.

There is an independent community plugin directory (https://deepseek-harness-plugin.com/en-US/plugins/) for retrieving, categorizing, and providing installation commands. It is not an official app store of DeepSeek / Horizon Robotics, and has no subordinate relationship with the official repository. The directory is categorized by functions such as interface enhancement, tools and capabilities, models and providers, etc. As of the writing of this article on 2026-08-18, there are approximately 288 plugins in the directory.

When using dsh for daily coding, reading error logs, and referencing UI screenshots, you will encounter a very specific limitation: if the main conversation model is a pure-text deepseek-v4 series, it cannot view images natively. If you upload a screenshot into the conversation, the model will either refuse to process it or only make random guesses based on the file name. As a result, many “vision bridge” plugins have emerged in the community, with different approaches: some convert images to text before the message reaches the model, some register pixel-level tools, and some use MCP. This article introduces dsh-vision maintained by william-jin-cmu: it does not modify the main model, but only registers a view_image tool, outsourcing the “image viewing” task to any OpenAI-compatible vision-language model (VLM).

There are other repositories also named dsh-vision in the same community directory (such as the plugins with the same name from oil-oil and linenxi-ctrl), with different installation addresses and implementations. All mentions below refer to the one corresponding to the directory entry dsh-vision-william-jin-cmu.

What is this¶

dsh-vision is a DeepSeek Harness plugin maintained by william-jin-cmu, licensed under BSD-3-Clause, primarily written in TypeScript. Its GitHub repository is at https://github.com/william-jin-cmu/dsh-vision, with the npm package name @dsh-external/dsh-vision, and the current manifest version is 0.1.0. The community directory categorizes it under “Interface Enhancement”, with an inclusion date of 2026-08-15; the repository was created on 2026-08-05, and the latest push was on 2026-08-13. As of the day this article was verified, the star count on both the directory page and GitHub API was 33.

The problem it solves can be summed up in one sentence: pure-text DeepSeek cannot view images, and the plugin adds a view_image tool to the runtime. The model calls this tool with its question and the image source (for OCR, counting, reading charts, viewing UI layouts, and any visual questions), the plugin forwards the image and question to any OpenAI-compatible VLM endpoint, and returns the answer as text. Both the directory page and README state that after installation, dsh’s web, TUI, remote channels and other entry points will all gain access to this tool.

Technically, it is a native Cordis plugin that depends on @deepseek-ai/dsh-tools, @deepseek-ai/dsh-system-prompt and schemastery, using the runtime’s built-in fetch to call /chat/completions, without introducing Python, uv or MCP. The README says the bridge format is consistent with Qwen-MM-Plugins’ vision_chat from the official Qwen team: one image_url plus one text question.

You need to clarify the boundary first: it will not automatically convert the image block you paste in the input box into text and feed it to the main model. Its working mode is tool calling — the user mentions a local image or a URL, the model decides to call view_image, and then continues reasoning based on the returned text. If what you want is “paste an image and get a description automatically, with the image block in the message replaced by the description”, that is the workflow of another type of plugin, do not mix it up with this one.

Core Functions¶

Based on cross-verification from the directory detail page, README, and repository source code (src/index.ts, src/vlm.ts), the current capabilities are as follows.

Register the view_image tool.
The tool description is straightforward: view an image and answer questions about it. It has two parameters:
- source (required): the image source, which can be a local absolute path, an http(s) URL, or a data: URL.
- question (optional): what you want to ask about this image. If not provided, the source code defaults to a comprehensive description, including the visible text, overall layout, and prominent details.

A small section will be added to the system prompt to tell the main model: it cannot see images by itself, but whenever there is a screenshot path, image URL, chart, UI draft or anything related to vision, it should call view_image, and the question should be specific. It is better to make multiple focused calls than to ask a vague, broad question all at once.

Hand images over to any OpenAI-compatible VLM.
Local files will first have their MIME type determined by their extension, be read as base64, and then sent as an inline data: URL; http(s) and existing data: URLs are forwarded as-is. The source code supports local extensions including .png, .jpg, .jpeg, .webp, .gif, .bmp, .tif, .tiff, .heic. The default maximum size limit is 10 MiB (maxImageBytes, configurable), and the default timeout is 60 seconds. The request will carry the AbortSignal from the tool execution, so if the user cancels the conversation, the request sent to the VLM will also be aborted.
Switch backends with one set of baseURL + apiKey + model.
The common combinations given in the README are as follows (endpoints and model names are subject to the repository documentation; vendor pricing and quotas may change, this article only reproduces the documentation and is not intended as long-term pricing quotes):
- Default free tier: https://open.bigmodel.cn/api/paas/v4, model glm-4.6v-flash.
- Paid upgrade for the same endpoint: glm-4.6v.
- Alibaba Cloud Bailian compatible mode: https://dashscope.aliyuncs.com/compatible-mode/v1, the documentation example is qwen3-vl-flash; for screenshots/GUI scenarios, the documentation recommends switching to qwen3.7-plus, and qwen3.8-max for difficult images.
- Volcano Engine Ark: https://ark.cn-beijing.volces.com/api/v3, the documentation example is doubao-seed-2-1-turbo-260628 with a date suffix. Short names (such as doubao-seed-2.0-lite) will return 404 as noted in the README, and the available list should be checked via Ark’s GET /api/v3/models.
- Offline: http://localhost:11434/v1, for example qwen3-vl:4b, using local Ollama, no key required.
- Reserved: As of the writing of this article in August 2026, DeepSeek’s official image recognition API has not yet been launched, and the official statement is “soon”; once launched, according to the documentation, only one line of configuration needs to be changed, using the existing DeepSeek key.

When using the default Zhipu AI endpoint, the source code also has a free tier fallback chain: if the main model returns 429 / 404 / 5xx, it will try glm-4.1v-thinking-flash and then glm-4v-flash in sequence. If you customize fallbackModels, it will follow your custom list; this Zhipu AI fallback chain will not be automatically applied if you change the default baseURL or main model.

Handling of keys, reasoning blocks, and error messages.
The reading order of the API key is consistent in the README and source code: plugin configuration apiKey → environment variable VISION_API_KEY → DSH_VISION_API_KEY (only recognizes exported values; the documentation states that since dsh 0812, .env files prohibit DSH_ prefix variables) → ZHIPUAI_API_KEY → DASHSCOPE_API_KEY. The recommended name to put in ~/.dsh/.env is VISION_API_KEY. No key is needed when baseURL points to localhost / 127.0.0.1 / ::1. Keys in error messages will be replaced with ***. Reasoning blocks embedded in the response from thinking models will be stripped; if the entire reply only contains reasoning and no answer, you will be prompted to increase maxTokens. The documentation recommends setting maxTokens: 2048 at minimum for such models.

The README also includes a test table compiled by the author on 2026-08-05, covering Q&A for 4K screen screenshots, involving about 10 models including Zhipu AI, Bailian, Ark, Kimi, etc., with latency ranging from about 2.9 seconds to 21 seconds. This is a full-link call record from the repository author, not a third-party review, and environment, question set, and peak current limits will affect the results, so it can only be used as a reference when selecting a model.

Installation and Activation¶

The installation command given by the community directory is as follows, run it in the DeepSeek Harness terminal:

dsh plugin add github:william-jin-cmu/dsh-vision

For reproducible installations, fix the commit hash as shown on the directory page:

dsh plugin add github:william-jin-cmu/dsh-vision#commit

Replace #commit with the specific commit hash. According to the official CLI documentation, the full form of installing a GitHub plugin to a specific profile is dsh plugin --profile <profile> add github:owner/repo; the directory page does not include --profile, so follow the original text on the page. When installing from Git source code, pnpm 10+ may block the prepare build script; if the first installation fails, follow dsh’s prompt to add allowBuilds to the corresponding profile’s pnpm-workspace.yaml and run the command again.

The README also provides a local mounting method that does not go through the plugin manager: clone the repository locally, link the host’s @deepseek-ai/dsh-tools and schemastery to the plugin’s node_modules, then add the configuration to ~/.dsh/config.yaml. The clone address in the documentation is written as https://github.com/dsh-external/dsh-vision, which is the same repository as william-jin-cmu/dsh-vision when verified against the GitHub API. The README also mentions that when using DSH Companion, the plugin is already bundled with the application, as well as the optional dshx install / dsh registry install; these two lines only appear in this README, and this article did not test them in a separate environment, please refer to the current repository documentation if needed.

There is a required pre-installation note on the directory page: the plugin runs with the permissions of the current dsh process, and may execute code during installation. Check the source code repository and license before installing.

Configuration and Usage¶

The configuration block given by the repository is as follows, which can be written in the plugin configuration:

dsh-vision:
  baseURL: https://open.bigmodel.cn/api/paas/v4
  apiKey: "" # Leave blank to read from environment variables
  model: glm-4.6v-flash
  maxTokens: 2048
  timeoutMs: 60000
  maxImageBytes: 10485760

When apiKey is left blank, it will be read in the environment variable order mentioned in the previous section. There is also fallbackModels in the source code, which defaults to an empty array; the free tier fallback chain will only be enabled when it is empty, and the default Zhipu AI endpoint + glm-4.6v-flash are being used.

The recommended way to store your key is to put it in ~/.dsh/.env:

VISION_API_KEY=your Zhipu AI or Bailian API key

The default model glm-4.6v-flash is classified as Zhipu AI’s free vision tier according to the README, and you need to apply for a key at https://open.bigmodel.cn first. Without a key, and if the endpoint is not localhost, the tool call will directly throw an error, prompting you to configure apiKey / VISION_API_KEY, or switch to Ollama.

The calling process in the README is as follows (replace the path with the absolute path on your machine):

User: What's the error in ~/Desktop/error.png
Model → view_image(source="/Users/me/Desktop/error.png", question="What is the full text of this error?")
     ← "TypeError: Cannot read properties of undefined (reading 'map') at …"
Model: This is a … suggestion …

The repository also describes an actual process with dsh web + DeepSeek-V4-Flash: tell the pure-text model that there is an images.jpeg on the desktop, the model locates the file by itself, calls view_image with the question, and then writes the description returned by the VLM into the subsequent response. You can use the same wording in web, TUI, or remote channels, for example:

Look at /home/me/screenshots/fail.png, copy the full red error text verbatim, and point out which line of code threw it.

Open https://example.com/chart.png, read the numerical comparison between 2025 and 2026 in the bar chart.

Writing specific questions is more effective than just saying “look at this image”. This is the recommendation in the plugin’s system prompt, which also aligns with the tool’s design of “answering questions, not just providing image descriptions”.

When switching backends, you only need to modify the same set of fields. For example, to switch to local Ollama:

dsh-vision:
  baseURL: http://localhost:11434/v1
  apiKey: ""
  model: qwen3-vl:4b

To switch to Alibaba Cloud Bailian:

dsh-vision:
  baseURL: https://dashscope.aliyuncs.com/compatible-mode/v1
  apiKey: ""
  model: qwen3-vl-flash

The Bailian API key can be stored in DASHSCOPE_API_KEY, or uniformly use VISION_API_KEY.

Applicable Scenarios and Notes¶

It is suitable for these situations:
- The main model is a pure-text DeepSeek, and you need to view error screenshots, terminal outputs, UI layouts, charts, or scanned documents on a daily basis.
- You want the image recognition backend to be replaceable: cloud free tier, Bailian/Ark paid tier, or local Ollama, using the same tool interface.
- You want view_image to be available across web, TUI, and remote channels, instead of only taking effect in a specific interface.

There are several constraints that must be followed before use, not optional settings.

First, the plugin runs with the permissions of the current dsh process. view_image will read local files according to the given absolute path, and may execute code during installation and operation. Check the source code and BSD-3-Clause license before installing; pin the GitHub source to a specific commit in production environments.

Second, the default path will send images to third-party VLMs. Local files will be encoded as base64 and POSTed to the baseURL you configured. Desktop screenshots, customer documents, error pages containing keys, will all leave your local machine. Only when baseURL points to localhost (such as Ollama) will the images not leave your machine. Choosing a cloud or local backend is equivalent to deciding your data boundary.

Third, this is tool calling, not a native multimodal main model. The main model still cannot see pixels; all it can “see” is the text returned by the VLM. The quality of descriptions, OCR accuracy, and chart reading results all depend on the vision model you select and the way you phrase your questions. If the main model does not call the tool, the plugin will not automatically scan images in the background.

Fourth, there are many plugins with the same name in the directory. dsh-vision, dsh-vision-router, dsh-vision-toolkit, dsh-vision-proxy, dsh-vision-bridge are not the same project. The installation command must include the william-jin-cmu/dsh-vision segment, do not just search for the name and install any random one.

Fifth, free tiers have rate limits. Zhipu AI’s free models use the public capacity pool, and when encountering 429 errors, the default configuration will fall back to older free vision models, which will have reduced detail. If the service is unstable during peak hours, switch to a paid tier, Bailian, or a local model. Ark model IDs include date suffixes, and short names returning 404 is a noted pitfall in the documentation.

Sixth, dsh itself is still in developer preview, and the plugin declares a minimum engine requirement of dsh >= 0.0.1. After the host upgrades, the tool registration method, profile layout, or .env variable rules may change, please refer to the current dsh documentation and plugin README at that time.

Summary¶

dsh-vision does a very narrow set of things: adds a `view_image

Add Image Recognition Capability to Plain-Text DeepSeek Harness Using dsh-vision