DeepSeek Harness Plugins vs Skills

DeepSeek Harness plugins are runtime extensions that change what the agent environment can do. Skills package reusable instructions. The distinction sounds like vocabulary until you notice they need different reviewers: a plugin changes what the agent can reach, a skill only changes how it works.

Key Takeaways:

• Plugins change runtime capability; skills package a reusable method
• The review test is one question: does this change the environment, or the procedure?
• Harness skills are discovered through a catalog and loader, but portability depends on the runtime, resources, and configuration around them
• Managed skills move discovery, loading, and workspace access into the service — they do not remove the need to trust the source

Vera here. I learned this during a small extension review for a reporting workflow. At first the team called everything a "skill": one item summarized meeting notes, one cleaned CSV files, one added browser access, and one changed where model calls were routed.

When I separated them, the difference became obvious. Two were reusable methods. The other two changed the runtime environment. That meant a different review owner, because browser access and model routing are not just writing instructions — they change what the agent can reach and how the work runs.

My quick test is this: does the change alter the environment, or the method? I ask because non-technical teams often treat every extension as a workflow asset, then discover later that one item quietly changed tool access, model routing, or sandbox behavior.

The Short Difference

A plugin changes what the system can do. In DeepSeek Harness, Cordis plugins contribute services, typed events, and reversible effects to a shared context — including the model adapter, tool registry, session log, and agent loop itself.

A skill provides reusable instructions or resources that shape how an agent performs a workflow. The Harness skill capability family discovers reusable agent instructions through a provider-neutral catalog and loader, split across packages for registration, filesystem discovery, and the model-facing loader.

A plugin may add the capability. A skill shapes the method. Notice that the skill family is itself delivered as plugins, which is exactly why the words get tangled.

What a Plugin Means for an Everyday User

For a non-technical user, a plugin is not a smarter prompt. It may affect model access, files, tools, sandbox behavior, or what happens after a tool call.

Capabilities added behind the interface

Cordis plugins change the environment behind the screen. A model adapter connects models. Provider routing decides where requests go. A sandbox limits where work can happen. The agent loop controls step flow. None of that is visible in the chat window.

Maintenance owned by the operator

Plugins need an operator because they behave like software dependencies. The Harness repository marks the project as developer preview and warns, in capitals, that compatibility-breaking changes are coming.

Someone must update, test, and disable plugins when needed. In my own checklist, plugin review splits into six checks: what it can read, what it can write, which model or provider it touches, whether it uses network access, where logs are stored, and who can disable it.

Skill review is lighter: source instructions, output format, examples, stop rules, and human approval points. That asymmetry is the whole argument for keeping the two words apart.

Two plugins published in the days after launch show what that buys in practice. Anionex/dsh-vision-toolkit (347 stars, MIT, created 13 August 2026) gives a text-only model a way to work with images, long screenshots, and UI layouts, which is capability the underlying model does not have on its own. NanmiCoder/dsh-agent-teams (257 stars, MIT) goes the other direction and adds multi-agent orchestration on top. Neither is a prompt or a workflow; both change what the runtime can physically do, which is exactly the line that separates a plugin from a skill. Star counts verified 15 August 2026.

By 17 August a second vision plugin had overtaken the first. ysr666/dsh-vision-router (459 stars, MIT, created 13 August 2026, release v1.4.4) does the same category of thing as the vision toolkit above, giving a text-only Harness agent image tools, and it reports 257 tests and no Python dependency. Its pitch is a built-in vision chain that needs no key of its own, which is the part to think about: a plugin can extend what the runtime can physically do, but the capability still runs somewhere and somebody still pays for it. Two independent plugins solving the same missing sense in one week says the gap is real; it does not tell you which one will still be maintained in November.

What a Skill Means for an Everyday User

An agent skill is closer to a reusable recipe. It may include instructions, examples, files, scripts, or resource guidance, but its job is repeatability.

Reusable instructions and resources

For everyday work, a skill might define how to write a brief, compare vendor pages, clean a CSV, or prepare a response. Our guide to AI agent skills frames the value around rules, examples, output shape, and review points.

A workflow you can inspect

A good skill shows what it reads, what it produces, and where it stops. That visibility is what makes skills different from hidden runtime extensions. Still, a SKILL.md file or a managed skill may rely on tools, files, or model behavior that another environment does not have.

When a Plugin Changes What You See, Not What You Ask

omdsh-dev/dsh-genui (327 stars, MIT, created 13 August 2026) is a clean example of the boundary this article is drawing, because it changes the answer's surface without touching the instructions you give. Ask about this month's orders and instead of a paragraph you get stat cards, a trend chart and a slider you can drag, rendered inline through a dsh-ui fence, with the model responding to the interaction.

Nothing about that is a skill. No prompt was rewritten, no output format was specified by you; a runtime component started intercepting a fence type and mounting a render tree. That is exactly what makes it a plugin, and exactly what puts it on the operator's side of the six-check list above.

Its release notes make the maintenance argument better than I can. The plugin ships two rendering channels and picks one at startup: a registry channel when the host exposes the fence-registry extension point, and a DOM channel that watches the session DOM when it doesn't. Fence discovery went multi-surface in 0.8.3 because different DSH builds render code blocks with different class names, and the plugin now matches the stock md-code-block surface, the deepsuite-style .code-block variants, and any element whose banner labels it dsh-ui. Streaming render arrived in 0.7.2.

Read that as a changelog and it's impressive engineering. Read it as an operator and it's three defensive workarounds for a host whose DOM keeps moving, in a project the DeepSeek Harness README itself marks developer preview. Skills don't accumulate that kind of debt, because they never depended on the host's markup in the first place.

Since that paragraph was written, dsh-genui went from the biggest thing on this shelf to the smallest. The surface layer has its own directory and community site now, dshfind.com, and the plugins sitting on that shelf are an order of magnitude larger (GitHub, 25 August 2026): omdsh-dev/DSH-better-sidebar at 2,833 stars, ccch1mneyyy/dsh-TUI at 2,493, and zhu1090093659/dsh-web at 5,950. Every one of them showed up inside the same week of August 2026, and every one ships MIT or Apache-2.0.

Size on its own is trivia. The useful part is what the large ones refuse to do, and their own docs are blunt about it: dsh-TUI says it does not patch DeepSeek Harness core and that removing the plugin leaves no core modifications behind, while dsh-web mounts through the official profile mechanism without touching DSH source. Neither one reads the session DOM. Neither one has to, because a terminal front door and a profile-mounted web bundle both attach to extension points the host actually publishes.

dsh-genui gets no such luxury, since fences render inside markup nobody promised to hold still. The debt in that changelog isn't sloppiness, then; it's the toll for wanting to change the one surface the host never committed to.

better-sidebar prints its share of that toll on the box. Its README pins the DSH builds it supports by name, down to the release candidate: 0.1.0-rc.8, 0.1.1-rc.1, 0.1.1-rc.2. That's more honest than most plugins bother to be, and it's also a plain statement of what you're adopting, namely a workbench that tracks release candidates of a project whose own README says developer preview.

Follow the surface far enough and it stops being a plugin at all. lencx/Minke (487 stars, Apache-2.0, and explicitly not an official DeepSeek product) wraps DSH in a desktop app, then adds the thing everyone eventually asks for: picking a task back up from a phone. Minke Host projects the workspace into a responsive web client instead of streaming pixels, with Tailscale Serve over HTTPS the one validated route while Tailscale Direct IP and Cloudflare Access stay experimental. Read that setup for what it is and your phone isn't reaching a service, it's reaching your laptop through a tunnel, for exactly as long as your laptop stays awake. Close the lid and the workspace goes with it. That's the seam MoClaw sits in: the workspace runs on hardware that doesn't sleep when you do, so resuming from a phone stops depending on the state of your desk, and it sits beside a local DSH install rather than in place of one.

Why the Difference Changes Portability

Plugins and skills work together, but they travel differently. A plugin often depends on runtime versions, permissions, and packages. A skill depends on instructions, resource paths, and available tools.

Harness presets add another layer. A preset can give one session its own tools and prompt sections while other sessions keep different compositions. So "same system" does not reliably mean "same environment" — two sessions on one install can disagree about what the agent can do.

If you are comparing this against other ecosystems, Claude Skills vs OpenClaw Skills covers the same portability problem across vendors.

Questions to Ask Before Adopting Either

The safest choice is the one your team can explain and maintain.

Who installs and updates it? A plugin needs a runtime owner. A skill needs a method owner. In a small team those may be different people, and pretending otherwise is how things rot.

Can you review what it reaches? For plugins, review tools, files, credentials, routes, and network access. For skills, review resources, scripts, approval stops, and outputs.

Can you move it elsewhere? Maybe, but do not assume it. Harness skills, managed skills, and OpenClaw-compatible SKILL.md files may all need edits in another environment. Test with non-sensitive data first.

How Managed Skills Reduce Overhead

Managed skills reduce overhead by moving discovery, loading, workspace access, and part of the review UI into the service. MoClaw's Web Chat is where skills run and tasks get reviewed, while the AI Cloud Computer gives those workflows a persistent workspace.

That does not make skills setup-free. You still need to trust the source, inspect instructions, approve sensitive actions, and limit private data.

FAQ

Can one person create a skill for someone else to run?

Yes, but the runner should receive the skill text, files, setup notes, and approval boundaries. For client work, keep an approved copy rather than a link.

What happens if a skill author removes the original download?

Availability after removal is not documented as a universal guarantee. Keep an internal copy, record the source or commit, and test it before recurring use.

Do plugins and skills maintain separate version histories?

They can, but no universal rule is publicly documented across all Harness plugin and skill sources. Track plugins as dependencies and skills as workflow assets.

Where should users report a malicious third-party extension?

Report it to the platform or repository that distributes it, then remove access. For GitHub-hosted extensions, use the issue, discussion, or security contact when one is available.

Who owns instructions written by an outside contractor?

Define ownership before work starts. The client should control the skill text, resource files, scripts, version notes, and credentials, and contractor access should be removable.

Plugins Are Runtime Choices, Skills Are Workflow Choices

DeepSeek Harness plugins and skills answer different questions. Plugins decide what the runtime can become. Skills decide how repeated work should run. For non-technical users, treat plugins as operator-owned infrastructure and skills as reviewable workflow assets — and when someone hands you an "extension," ask which one it actually is before installing it.

Checked on 14 August 2026 against the DeepSeek Harness repository, architecture documentation, and skill and preset package READMEs. DeepSeek Harness is in developer preview, so package layout and behavior should be rechecked before production use.