FURTHER READING
Further Reading for DeepSeek Harness
Tutorials, docs, and step-by-step walkthroughs for designing with DeepSeek Harness, as listed in the published guide.
DeepSeek Harness 
OpenDesign Design With
DeepSeek Harness in
OpenDesign.
How to design interfaces with DeepSeek Harness in OpenDesign: a reusable console profile, skills and provider choice, one admin users table from brief to reviewed file, and the limits to know before you start.
THREE DEEPSEEK HARNESS STARTING POINTS
Pick Your DeepSeek Harness Entry Point
THIS GUIDE · UI DESIGN
Build an Interface With DeepSeek Harness
The path here runs from brief and references through design rules to an HTML result you review.
Read this guide SETUPInstall DeepSeek Harness Without Prerequisites
No preinstalled Node.js, pnpm, or dsh is required. Run the one-line installer for your operating system: it installs the DeepSeek Harness…
Go to setup COMPARISONSee How DeepSeek Harness Differs
Where DeepSeek Harness stands apart from DeepSeek TUI (`deepseek` / `codewhale`), OpenCode, and Claude Code for design tasks—and when another workflow is the better pick.
See the comparisonOn This Page Example
DeepSeek Harness Design Task in Full
From Brief to Interface in DeepSeek Harness
One design task traced from the brief and constraints you hand over to the artifact that returns—and the checks you still run before calling it done. The interface below is illustrative, built for this page; it is not a recorded DeepSeek Harness run.
1Design Brief and Constraints
BriefCreate the users page for an admin console: a searchable table covering role, team, status, and last active, plus bulk actions and pagination. Use the console skill through a reusable profile. Desktop and phone.
- Design systemOpenDesign paper canvas with Albert Sans and a single green accent
- BreakpointsDesktop at 1440px and mobile at 390px without horizontal scroll
- InteractionsSearch, filters, row selection, bulk actions, and pagination
- OutputA single self-contained HTML file using stable
data-od-idhooks
2Who Does What: You, DeepSeek Harness, OpenDesign
- You
You write the brief, choose the design system, and set the acceptance criteria.
- DeepSeek Harness
DeepSeek Harness plans the layout, writes the HTML, CSS, and JavaScript, then revises on request.
- OpenDesign
OpenDesign supplies the design system and skill, renders the preview, and keeps each version as a project file.
- Review
Before handoff, check visual hierarchy, 8px-grid spacing, both breakpoints, and every interaction.
3DeepSeek Harness Artifact: Admin Table at 1440px and 390px
4Review Before Handoff
Layout
Grid and Spacing
Toolbar, table, and pager align to the 8px grid; fixed column widths keep rows from jumping.
Hierarchy
Visual Hierarchy
Name and role lead; the accent appears only on the owner role.
Responsive
Mobile Layout
The table turns into a list showing name, email, and role; filters move into a sheet.
Interaction
Interaction Checks
Search, filter by role, select two rows, run a bulk action, then page forward.
Fit
Where DeepSeek Harness Fits—and Where It Does Not
DeepSeek Harness Fits When
- Project instructions. Pull brand and component rules from AGENTS.md or CLAUDE.md.
- Reusable skills. Put frontend craft and verification under `.dsh/skills` or `.agents/skills`.
- Provider choice. Route code/spec work to text-only DeepSeek and screenshots to an image-capable route.
- Composable profiles. Assemble a focused runtime from the tools, policy, and UI plugins the workflow requires.
Choose Another Workflow When
- You need editable vector files. The output is HTML, not an editable design document; look to a separate vector workflow for the asset format you need.
- You have no reference and no constraints. Without a design system or examples, the result tends toward a generic look; write the brief before generating.
- You do not have the credential this agent needs. You need a DeepSeek API key or another configured provider credential. OpenDesign neither provides nor proxies credentials.
- Your team works in DeepSeek or Reasonix. Those agents have dedicated pages; setup changes by agent even though the design workspace stays consistent. See related agents.
Compatibility
DeepSeek Harness Requirements Before You Begin
This page addresses DeepSeek Harness when OpenDesign’s desktop app is the connection point. References published as of 6 September 2026 were consulted.
Tool ScopeDeepSeek Harness, by DeepSeek AI
DeepSeek Harness (`dsh`) is DeepSeek AI’s official open-source agent harness. Models, tools, sessions, permissions, filesystems, skills, subagents, and UI are assembled as Cordis plugins by its local Web UI and headless runner. The focus here is designing interfaces with DeepSeek Harness inside OpenDesign, not operating DeepSeek Harness’s own interface. Which agents OpenDesign can use is recorded in its setup notes.
Accounts and AuthenticationDeepSeek API key or another configured
A DeepSeek API key, or another provider credential already configured. In OpenDesign, go to Settings → Models & providers → Local CLI and rescan. No quota or price is promised on this page.
System and VersionsDesktop app or source
Desktop builds are listed on the download page. Node.js and pnpm requirements from the source quickstart matter when running from source; they do not apply to a desktop package install. The minimum DeepSeek Harness version compatible here has not been verified.
Connection CheckThe success signal
Use the connection steps your installed version displays, then give DeepSeek Harness one modest task. Check that DeepSeek Harness carried it out and that the artifact can be opened. Merely downloading does not prove the connection works.
Start with the desktop app
Three Steps to Set Up DeepSeek Harness
Start by downloading; finish the DeepSeek Harness setup that matches your installed version; then verify one small result. Following this route does not require building OpenDesign from source.
- 1
Download the OpenDesign Desktop App
Pick the installer built for your machine, install it, and launch the app.
Download OpenDesignCHECKPOINTYou should see the desktop app open. If it is already installed, go on to the next step instead of downloading it again. - 2
Prepare Your DeepSeek Harness Connection
Use the DeepSeek Harness instructions that ship with the version you installed. In OpenDesign, open Settings → Models & providers → Local CLI and choose rescan.
deepseek-ai/deepseek-harnesscurl -fsSL 'https://open-design.ai/install-dsh.sh?version=1' | shTaken from the DeepSeek Harness setup notes in the published guide; verify the current command against the vendor documentation.
CHECKPOINTVerify the agent and account you meant to use. Should it be unavailable, review compatibility first rather than moving to a larger task. - 3
Run a Single Small DeepSeek Harness Task
Keep the brief modest, which lets you judge the entire loop, one revision included.
Starter briefCreate a settings screen containing a profile form and a save confirmation. Apply my design rules. Verify it at desktop and mobile widths.
CHECKPOINTOpen the result, check the save state, and ask for one specific change. The generated file starts the review; it is not the finish line.
If OpenDesign will be run from source, use the technical quickstart instead.
The DeepSeek Harness design workflow
DeepSeek Harness Design Workflow: Five Steps
This walkthrough follows the admin users table from brief to reviewed file. Each step names your input, DeepSeek Harness's work, OpenDesign's contribution, and what you verify.
- 1
Design Brief
A short brief in plain language — three to six lines. State who uses the screen, what it must accomplish, and which platforms matter.
- YouDraft the brief. If you have a reference screenshot, attach it.
- DeepSeek HarnessParses the brief and the project’s instruction file; if a requirement is ambiguous, it asks before proceeding.
- OpenDesignHosts the project and the prompt surface, and supplies the skill that matches the artifact type.
- CheckMake sure the brief spells out acceptance criteria. Settling them before generation costs less than fixing them afterward.
- 2
Design Constraints
A design system plus a few non-negotiables. That combination is what keeps the output on-brand instead of generic.
- YouChoose the design system, then state breakpoints and any components that must appear.
- DeepSeek HarnessBefore writing any code, it loads DESIGN.md tokens and the design posture rules into context.
- OpenDesignShips the design-system library and binds your chosen system into the skill template.
- CheckCheck that tokens match your brand: a single accent, correct fonts, correct radius.
- 3
Generate the Interface
DeepSeek Harness produces one self-contained HTML file — layout, styles, interactions, and stable hooks.
- YouWait, or answer one clarifying question. There is nothing to configure.
- DeepSeek HarnessIt plans the sections, writes HTML, CSS, and JavaScript, runs the file, and repairs whatever fails.
- OpenDesignStores the artifact in the project folder and indexes it so the preview can find it.
- CheckHold off. Judge the file after it renders, not by reading the source.
- 4
Preview
Inside OpenDesign, the file renders at the widths you requested. This is the point where the design gets judged.
- YouChange widths, click through interactions, and leave comments on individual elements.
- DeepSeek HarnessIt reads your preview comments and prepares the next revision.
- OpenDesignRenders the preview and exposes
data-od-idtargets so comments and edits can attach to elements. - CheckCheck hierarchy, contrast, overflow at 390px, focus states, and restraint in accent usage.
- 5
Revise and Verify
Ask for changes by pointing to elements in the preview. Each revision arrives as a new file; nothing is overwritten without a trace.
- YouTranslate comments into requests and decide when the task is finished.
- DeepSeek HarnessIt applies changes in place and reruns the file.
- OpenDesignKeeps versions side by side; when you finish, export an image or the HTML.
- CheckRe-check only the changed area, then the full page once at each breakpoint.
Resources
DeepSeek Harness Design Resources
Skills Browse skills Design systems Browse systems Templates Browse templates Plugins Browse plugins
Design Skills
Artifact types DeepSeek Harness can generate in OpenDesign, with one skill per type.
Design Systems
Brand tokens and components you bind before DeepSeek Harness generates any output.
Templates
Starting points for decks, landing pages and product screens.
DeepSeek Harness Design Plugins
Design plugins built for the Harness, each with its own setup notes.
Limitations
DeepSeek Harness Limits, Manual Checks, and Fallbacks
- ScopeThis page is about DeepSeek Harness as an agent connected to OpenDesign, not every feature of DeepSeek Harness.
- Usage LimitsUsage limits and cost depend on the credential you use (DeepSeek API key or another configured provider credential). No claim about free quotas is made here.
- NetworkLocal project files do not imply offline inference. Check your agent’s provider settings and data policies before sharing sensitive inputs.
- Output Is HTMLArtifacts come as HTML files, not vector design files.
- Manual ReviewYou review accessibility, real content, brand fit, and interaction correctness in the preview. Any self-check by the agent is only a first pass.
- FallbackIf the agent is unavailable or a task fails, consult the installed version’s connection instructions and authentication. Preserve the error and the last working artifact before you change configuration.
FAQ
Common Questions About DeepSeek Harness and OpenDesign
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.
How Do I Install and Run DeepSeek Harness?
Run the one-line installer for your OS — macOS/Linux: `curl -fsSL 'https://open-design.ai/install-dsh.sh?version=1' | sh` (PowerShell and CMD one-liners are in the setup section above). No preinstalled Node.js, pnpm, or dsh is required, and no `sudo` is needed. The installer opens `dsh web` at the end; 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 OpenDesign 0.19.1 or later, rescan Local CLI agents, connect the Harness card, and click Test.
Will the Installer Overwrite My Existing Node.js?
No. When environments are missing it installs an isolated Node.js and DeepSeek Harness toolchain inside your user directory; it does not modify the system Node.js or replace versions other projects use. If you already have compatible Node.js, pnpm, and dsh, the installer detects and reuses them instead of downloading again.
The Terminal Cannot Find Dsh After Installation — What Now?
Open a new terminal window first. OpenDesign scans the common user-level tool directories itself, so you normally do not need to edit PATH; if OpenDesign is already open, go to the Local Agent page and click Rescan. If detection still fails, confirm the installer’s final screen reported DeepSeek Harness as ready, then share that output together with OpenDesign’s test message when asking for support.
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.
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.
Status: developer preview; compatibility-breaking changes are expected
Developer: DeepSeek AI (official project)
License: MIT
Primary command: `npx @deepseek-ai/dsh web`
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.
Status: developer preview; compatibility-breaking changes are expected
Developer: DeepSeek AI (official project)
License: MIT
Primary command: `npx @deepseek-ai/dsh web`
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 harness carries the inputs; taste still comes from a design system, a focused skill, and concrete references.
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. OpenDesign’s role is to supply and organize those design inputs.
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 harness carries the inputs; taste still comes from a design system, a focused skill, and concrete references.
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. OpenDesign’s role is to supply and organize those design inputs.
Step 1: Install and configure DeepSeek Harness
You do not need Node.js, pnpm, or dsh preinstalled. Run the one-line installer for your operating system: it installs the DeepSeek Harness toolchain OpenDesign has verified, then opens the API-key setup page. The installer never touches your system Node.js and needs no `sudo` or administrator rights; an existing compatible environment is reused automatically.
macOS / Linux — open Terminal, paste this line, and press Enter (Apple Silicon, Intel Mac, and mainstream x64/arm64 Linux distributions are supported; Alpine Linux is not supported yet):
Windows PowerShell — open PowerShell, paste this line, and press Enter:
Windows CMD — open Command Prompt, paste this line, and press Enter:
Checks for compatible Node.js, pnpm, and DeepSeek Harness versions and reuses them when present — nothing is downloaded twice.
When environments are missing, installs an isolated Node.js and DeepSeek Harness toolchain inside your user directory.
Pins the release OpenDesign has verified, so automatic upgrades cannot break compatibility.
Verifies the SHA-256 of the Node.js download and stops the installation on mismatch.
Creates a `dsh` entry OpenDesign can discover, without overwriting your global Node.js.
Talks only to the OpenDesign install endpoint, nodejs.org, and the npm registry; it uploads no project files or API keys.
Open the Harness Web UI: The installer runs `dsh web` for you when it finishes. 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. Whenever you need to reconfigure later, run `dsh web` again.
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 OpenDesign.
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. OpenDesign reuses this user-installed dsh and its model configuration without copying the key into OpenDesign. The installer already pins the release OpenDesign has verified, so no manual version management is needed. See the official provider guide for the upstream credential behavior.
Use the current setup section for commands and version-specific details, which may change.
Historical command example from the previous guide; verify current syntax in the linked vendor documentation.
Historical command example from the previous guide; verify current syntax in the linked vendor documentation.
macOS / Linux — open Terminal, paste this line, and press Enter (Apple Silicon, Intel Mac, and mainstream x64/arm64 Linux distributions are supported; Alpine Linux is not supported yet):
Windows PowerShell — open PowerShell, paste this line, and press Enter:
Windows CMD — open Command Prompt, paste this line, and press Enter:
Checks for compatible Node.js, pnpm, and DeepSeek Harness versions and reuses them when present — nothing is downloaded twice.
When environments are missing, installs an isolated Node.js and DeepSeek Harness toolchain inside your user directory.
Pins the release OpenDesign has verified, so automatic upgrades cannot break compatibility.
Verifies the SHA-256 of the Node.js download and stops the installation on mismatch.
Creates a `dsh` entry OpenDesign can discover, without overwriting your global Node.js.
Talks only to the OpenDesign install endpoint, nodejs.org, and the npm registry; it uploads no project files or API keys.
Open the Harness Web UI: The installer runs `dsh web` for you when it finishes. 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. Whenever you need to reconfigure later, run `dsh web` again.
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 OpenDesign.
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. OpenDesign reuses this user-installed dsh and its model configuration without copying the key into OpenDesign. The installer already pins the release OpenDesign has verified, so no manual version management is needed. See the official provider guide for the upstream credential behavior.
Use the current setup section for commands and version-specific details, which may change.
& ([scriptblock]::Create((irm 'https://open-design.ai/install-dsh.ps1?version=1')))Historical command example from the previous guide; verify current syntax in the linked vendor documentation.
curl -fsSL "https://open-design.ai/install-dsh.cmd?version=1" -o "%TEMP%\install-dsh.cmd" && call "%TEMP%\install-dsh.cmd"Historical command example from the previous guide; verify current syntax in the linked vendor documentation.
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:
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.
Historical command example from the previous guide; verify current syntax in the linked vendor documentation.
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:
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.
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.Historical command example from the previous guide; verify current syntax in the linked vendor documentation.
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.
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.
DeepSeek Harness, DeepSeek TUI, and OpenDesign
DeepSeek Harness and DeepSeek TUI are separate projects with different executables. OpenDesign now supports both as local agents, so the choice is about which runtime you want — not whether either can enter the design workspace.
DeepSeek Harness (`dsh`) — Official DeepSeek AI plugin-first harness with local Web UI and headless profiles; first-party OpenDesign adapter — Using Harness sessions, providers, and plugin composition inside OpenDesign’s artifact workflow
DeepSeek TUI (`deepseek` / `codewhale`) — A separate terminal coding agent with its own OpenDesign 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
OpenDesign — 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 OpenDesign when you prefer that agent’s terminal-first workflow. They remain distinct runtimes even though OpenDesign can now wrap either one in the same design process.
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 OpenDesign adapter — Using Harness sessions, providers, and plugin composition inside OpenDesign’s artifact workflow
DeepSeek TUI (`deepseek` / `codewhale`) — A separate terminal coding agent with its own OpenDesign 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
OpenDesign — 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 OpenDesign when you prefer that agent’s terminal-first workflow. They remain distinct runtimes even though OpenDesign can now wrap either one in the same design process.
Tool — What it is — Best design use
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.
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.
Step 2: Download OpenDesign 0.19.1 or later
Once dsh works locally, the rest happens in OpenDesign. DeepSeek Harness integration is available in OpenDesign 0.19.1 and later.
Get the current desktop build from the OpenDesign download page, install it, and launch the app.
Get the current desktop build from the OpenDesign download page, install it, and launch the app.
Step 3: Detect DeepSeek Harness
Open Settings → Models & providers → Local CLI, then choose Rescan. Restart OpenDesign or rescan again if it was already open during installation. The DeepSeek Harness card appears when OpenDesign finds the `dsh` executable from step 1.
Step 4: Connect the OpenDesign profile
Select the DeepSeek Harness card. If it says “Connection setup required,” confirm “Install and select.” OpenDesign verifies its own component, asks dsh to install it into the `open-design` profile, rescans, and tests the connection.
This is the checkpoint: detected Harness version, “Synced from CLI,” and a working Test action.
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.
This is the checkpoint: detected Harness version, “Synced from CLI,” and a working Test action.
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.
Step 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.
DeepSeek Harness edits the real workspace; OpenDesign keeps the request, progress, preview, and final artifact together.
The boundary stays simple: Harness owns dsh, credentials, models, and sessions; OpenDesign owns the verified connection profile and design workspace. OpenDesign is independent from DeepSeek AI, and DeepSeek and DeepSeek Harness are trademarks of their respective owner.
Historical command example from the previous guide; verify current syntax in the linked vendor documentation.
DeepSeek Harness edits the real workspace; OpenDesign keeps the request, progress, preview, and final artifact together.
The boundary stays simple: Harness owns dsh, credentials, models, and sessions; OpenDesign owns the verified connection profile and design workspace. OpenDesign is independent from DeepSeek AI, and DeepSeek and DeepSeek Harness are trademarks of their respective owner.
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 OpenDesign to preview.Historical command example from the previous guide; verify current syntax in the linked vendor documentation.
Is DeepSeek Harness official?
Yes. It is developed by DeepSeek AI and published under the MIT license.