Design with DeepSeek Harness.
DeepSeek Harness can build landing pages, product interfaces, dashboards, and frontend prototypes because it can read a repository, edit real UI code, run commands, load project instructions, and keep a session across iterations. What it does not supply on its own is visual taste: useful design work still needs brand rules, references, tools, permissions, and a loop that renders and checks the result.
For interface work, make the brief and acceptance loop explicit. The default DeepSeek route is text-only, so the most reliable baseline is a code-and-spec workflow; attach screenshots only after selecting a model route that declares image input.
The model still needs visual direction. The simplest way to supply it is to connect DeepSeek Harness to Open Design: Open Design provides the design system, frontend skills, artifact preview, and review surface; dsh performs the coding work. This guide covers that workflow from the official [DeepSeek Harness product page](https://www.deepseek.com/harness/) and [source repository](https://github.com/deepseek-ai/deepseek-harness) to a finished interface.
Can DeepSeek Harness do design?
DeepSeek Harness can build landing pages, product interfaces, dashboards, and frontend prototypes because it can read a repository, edit real UI code, run commands, load project instructions, and keep a session across iterations. What it does not supply on its own is visual taste: useful design work still needs brand rules, references, tools, permissions, and a loop that renders and checks the result.
- Persistent design context: The default instruction loader reads `AGENTS.md` and `CLAUDE.md` from the project hierarchy. Put tokens, component rules, responsive breakpoints, and review criteria where every run can see them.
- Reusable skills: Local skills can live under `.dsh/skills` or `.agents/skills`. A frontend skill can package the exact brief, checklist, examples, and scripts that stop each UI task from starting at zero.
- Provider choice by task: The Web UI can configure DeepSeek, catalog providers such as Anthropic or OpenAI, and custom OpenAI-compatible endpoints. Use a declared image-capable route for screenshot input; use the native DeepSeek route for text, code, DOM, and spec-driven work.
The important limit is the same for every agent: composability is not taste. Without deliberate typography, spacing, component, and interaction constraints, the runtime will faithfully automate a generic result. Open Design’s role is to supply and organize those design inputs.
Step 1: Install and configure DeepSeek Harness
Start by making sure DeepSeek Harness works on its own. Install the tested dsh release, then open its local Web UI to configure the API key and model before opening Open Design. The developer preview requires Node.js `^22.19.0` or `>=24.0.0`.
# Open Design currently tests DeepSeek Harness 0.1.0-rc.6
# Requires Node.js ^22.19.0 or >=24.0.0
npm install -g @deepseek-ai/[email protected]
# Verify the local executable
dsh --version
# Start the local Web UI and configure a provider and model
dsh web
# Open http://127.0.0.1:3080- Open the Harness Web UI: Run `dsh web`. It normally opens `http://127.0.0.1:3080`; if the browser does not open, copy the address printed by the terminal and use that exact address.
- Add the DeepSeek API key: Continue past the preview notice, then save or apply the key when prompted. If the prompt does not appear, open Settings → Models → DeepSeek → API Key. Paste only the key — not `DEEPSEEK_API_KEY=...` and not quotes. The change takes effect immediately; you do not need to restart `dsh web`. Create one on the DeepSeek Platform if needed.
- Confirm the model, then close the setup UI: The DeepSeek provider should show as configured and its models should appear in the selector. If you see `MISSING_CREDENTIAL`, reopen the DeepSeek card and save the key again. After a test prompt works, press `Ctrl+C`; `dsh web` does not need to stay open while you use Open Design.
DeepSeek Harness stores provider credentials as write-only secrets: the UI can report whether a key is configured, but cannot read or display the plaintext key. Open Design reuses this user-installed dsh and its model configuration without copying the key into Open Design. For a dependable workflow, keep dsh pinned to the tested `0.1.0-rc.6` release. See the official provider guide for the upstream credential behavior.
Steps 2–5: Connect DeepSeek Harness to Open Design
Once dsh works locally, the rest happens in Open Design. DeepSeek Harness integration is available in Open Design 0.19.1 and later.
- 2 · Download Open Design 0.19.1 or later: Get the current desktop build from the Open Design download page, install it, and launch the app.
- 3 · Detect DeepSeek Harness: Open Settings → Models & providers → Local CLI, then choose Rescan. Restart Open Design or rescan again if it was already open during installation. The DeepSeek Harness card appears when Open Design finds the `dsh` executable from step 1.
- 4 · Connect the Open Design profile: Select the DeepSeek Harness card. If it says “Connection setup required,” confirm “Install and select.” Open Design verifies its own component, asks dsh to install it into the `open-design` profile, rescans, and tests the connection.
- 5 · Start a design task: Confirm the card shows the Harness version and “Synced from CLI,” then click Test. After the test passes, open or create a project, choose DeepSeek Harness and a synced model, and send your design request.
That completes the connection. The UI and `od agent setup deepseek-harness --json` use the same local setup path; each run starts `dsh --profile open-design --stdio`, while Harness keeps the session identity for later turns.
Create a polished product landing page in this workspace.
Use DESIGN.md, AGENTS.md, and the installed frontend skill as the visual contract.
Reuse the project tokens and components; include desktop and mobile states.
Run the app, inspect the rendered result, fix visible spacing and hierarchy issues,
and leave the final HTML and assets in the project for Open Design to preview.
The boundary stays simple: Harness owns dsh, credentials, models, and sessions; Open Design owns the verified connection profile and design workspace. Open Design is independent from DeepSeek AI, and DeepSeek and DeepSeek Harness are trademarks of their respective owner.
Run the UI build and review loop
For interface work, make the brief and acceptance loop explicit. The default DeepSeek route is text-only, so the most reliable baseline is a code-and-spec workflow; attach screenshots only after selecting a model route that declares image input.
- Start dsh from the repository, choose that directory as the workspace, and select the model route for this task.
- Put the brand contract in `AGENTS.md`, `CLAUDE.md`, or a referenced `DESIGN.md`: tokens, primitives, spacing, type, breakpoints, states, and forbidden patterns.
- Load a focused frontend skill from `.dsh/skills` or `.agents/skills`; keep examples and validation scripts beside the instructions.
- Ask the agent to reuse existing components, run the application, and validate responsive states with the project’s own tests or browser tooling.
- Review the visible result, record specific deltas, and iterate in small commits. Revert weak passes instead of layering fixes on a bad base.
A useful prompt names both the visual constraints and the verification evidence:
Implement the account dashboard in React + TypeScript.
Reuse the components and tokens named in AGENTS.md and DESIGN.md.
Use a 240px sidebar, a 12-column content grid, and the documented
mobile navigation pattern. Include loading, empty, error, and focus states.
Run the app and existing UI checks, inspect desktop and mobile breakpoints,
and report the exact files and states you verified.If a screenshot is essential, configure an image-capable provider first. DeepSeek Harness refuses an image before sending when the selected route does not declare image support — a useful guard against silently dropping the reference.
Make the workflow reusable with plugins and skills
DeepSeek Harness is most differentiated below the chat surface. Its plugin tree lets teams make the design workflow part of the runtime instead of a prompt pasted into every session.
- AGENTS.md and CLAUDE.md: The instruction plugin loads the user-global file and the project hierarchy, then notices relevant nested instruction files after first-party file operations. Use it for durable design rules, not one-off requests.
- Filesystem skills: The skill registry discovers project and user roots, ranks duplicates, and exposes a model-facing `skill` tool. This is a natural home for frontend craft, accessibility, responsive QA, and design-system procedures.
- Profiles and bundles: A profile stacks ordered plugin bundles plus user patches. Teams can maintain a design-focused composition with the provider, tools, permission policy, and skill sources they actually need.
- MCP and external capabilities: The source tree includes MCP client capabilities, but user-facing configuration is still developer-oriented. Treat integrations as versioned plugin work during the preview, not a stable checkbox workflow.
Before building a long-lived internal workflow, inspect the effective tree with `dsh --profile web --dump-config`. That output shows what is actually mounted and patchable; it is more reliable than assuming every package in the repository is active in the shipped profile.
Avoid the failures that ruin visual output
The biggest mistakes come from treating a preview like a stable product, treating a text-only route like a vision model, or treating a flexible harness like a source of visual taste.
- Pin before you customize: Compatibility-breaking changes are an explicit preview policy. Pin the npm version and keep profile patches small enough to review after an upgrade.
- Check the selected model’s modalities: The native DeepSeek chat-completions route is text-only. For screenshot-to-code, select and declare an image-capable provider route instead of assuming the attachment will be understood.
- Supply taste as data: Give the agent tokens, canonical components, reference states, and forbidden patterns. A modular runtime without a design contract still produces generic UI.
- Verify what the profile actually mounts: Repository packages are capabilities, not proof that the default profile enabled them. Inspect the composed config before documenting an integration or relying on it.
Each mitigation is a context and verification decision. That is exactly the work a design layer should make repeatable rather than leaving every project to rediscover it.
What the harness contributes to design
DeepSeek Harness (`dsh`) is an MIT-licensed agent harness developed by DeepSeek AI. The official product page presents the project; the GitHub repository carries the source, release history, and maintained guides. The public developer preview ships a local Web UI and headless profiles.
Its defining idea is “everything is a plugin.” Cordis composes a tree in which the model adapter, tool registry, agent loop, filesystem, shell, sandbox, skills, subagents, persistence, and UI can be mounted, replaced, or patched through profiles and bundles. The shipped `web` and `headless` profiles are starting points rather than fixed products.
- Local Web UI: `npx @deepseek-ai/dsh web` starts a browser workspace on `127.0.0.1:3080` by default. Add a model, choose a workspace, and run tasks from the conversation UI.
- Headless mode: The `headless` profile runs one fresh persisted session, prints the final answer, and exits — useful for scripted audits, builds, and repeatable design checks.
- Composable runtime: Profiles stack plugin bundles and your own patches. That lets a team change providers, tools, policy, and UI behavior without forking an agent loop.
- Developer: DeepSeek AI (official project)
- Status: developer preview; compatibility-breaking changes are expected
- License: MIT
- Primary command: `npx @deepseek-ai/dsh web`
DeepSeek Harness, DeepSeek TUI, and Open Design
DeepSeek Harness and DeepSeek TUI are separate projects with different executables. Open Design now supports both as local agents, so the choice is about which runtime you want — not whether either can enter the design workspace.
| Tool | What it is | Best design use |
|---|---|---|
| DeepSeek Harness (`dsh`) | Official DeepSeek AI plugin-first harness with local Web UI and headless profiles; first-party Open Design adapter | Using Harness sessions, providers, and plugin composition inside Open Design’s artifact workflow |
| DeepSeek TUI (`deepseek` / `codewhale`) | A separate terminal coding agent with its own Open Design adapter | A terminal-first DeepSeek workflow without the Harness profile architecture |
| OpenCode | Mature open-source, provider-agnostic terminal agent | Switching models inside a stable TUI workflow with AGENTS.md and MCP |
| Claude Code | Mature coding agent across terminal, IDE, desktop, and web surfaces | Frontend reasoning, image-heavy references, and established design integrations |
| Open Design | Agent-native design workspace and library around supported coding agents | Curated design systems, skills, visual artifacts, and a local workflow independent of one model vendor |
Choose DeepSeek Harness when you want its official Web UI, profile system, model catalog, and resumable Harness sessions. Choose DeepSeek TUI inside Open Design when you prefer that agent’s terminal-first workflow. They remain distinct runtimes even though Open Design can now wrap either one in the same design process.
Using DeepSeek Harness for design: FAQ
-
01 What is DeepSeek Harness?
DeepSeek Harness (`dsh`) is DeepSeek AI’s official open-source agent harness. It combines models, tools, context, sessions, policy, orchestration, and UI through a Cordis plugin tree. The public release is currently a developer preview under the MIT license.
-
02 How do I install and run DeepSeek Harness?
Install the tested CLI with `npm install -g @deepseek-ai/[email protected]`, then run `dsh web`. Continue past the preview notice and save only the API key itself under Settings → Models → DeepSeek → API Key. Confirm the provider and model work, stop the Web UI with `Ctrl+C`, install Open Design 0.19.1 or later, rescan Local CLI agents, connect the Harness card, and click Test.
-
03 Is DeepSeek Harness an official DeepSeek project?
Yes. The repository is published under the `deepseek-ai` GitHub organization and describes dsh as an agent harness developed by DeepSeek AI. It is MIT-licensed and explicitly marked developer preview.
-
04 Can DeepSeek Harness build UI from screenshots?
Only when the selected provider route declares image input. DeepSeek’s own chat-completions route in dsh is text-only, and the harness rejects image attachments before sending them on a text-only route. Use an image-capable provider for screenshots, or describe the target through code, DOM, tokens, and written specifications.
-
05 Does DeepSeek Harness support AGENTS.md and skills?
Yes. Its instruction plugin loads AGENTS.md and CLAUDE.md-compatible project files. Its filesystem skill provider discovers project skills under `.dsh/skills` and `.agents/skills`, plus configured user and bundled roots.
-
06 What is the difference between DeepSeek Harness and DeepSeek TUI?
They are separate tools. DeepSeek Harness uses the `dsh` executable and is an official plugin-first Web UI/headless runtime from DeepSeek AI. DeepSeek TUI uses the `deepseek` or `codewhale` dispatcher and is the separate DeepSeek adapter Open Design currently supports.
-
07 Does Open Design support DeepSeek Harness?
Yes. Open Design detects your official dsh installation, installs a verified Open Design-owned profile component after explicit confirmation, syncs the Harness model catalog, and runs DeepSeek Harness as a first-party local agent. Open Design does not install dsh or receive the provider secrets managed by Harness.
-
08 Where does DeepSeek Harness store my API key?
Configure the key in DeepSeek Harness, not Open Design. The official model guide says provider keys are stored in `$DSH_HOME/.credentials.yaml` as write-only secrets: the UI can see whether a key is configured but cannot read or display its plaintext value. Open Design does not ask you to paste the key into the app or write it into Open Design configuration.
Design with DeepSeek Harness in Open Design.
Install the official dsh runtime, connect it once, then use Open Design’s design systems, skills, synced models, and local artifact previews in one workflow.