跪拜 Guibai
← All articles
Artificial Intelligence · DeepSeek · AI Programming

Two weeks with DeepSeek Harness: five plugins that bend an AI client to your own toolchain

By 一拳不是超人 ·
Read original on juejin.cn ↗ Google Translate ↗ Alt translation

AI coding clients that lock tools and memory behind platform walls force developers to re-enter data and re-implement scripts for every model switch. DSH's plugin model, with Git-backed memory and no-kernel extension points, shows a path where your agent's capabilities travel as plain npm packages and Markdown files you already own.

Summary

DeepSeek Harness (DSH) ships as a desktop app whose agent loop is a single package, dsh-agent-loop, with everything else pluggable. Its README instructs writers to put new behaviors in plugins rather than rewrite the kernel. That philosophy held up under a two-week test: five MIT-licensed plugins now cover long-term memory stored as Markdown in a user's own Git repo (dsh-memory-git), a full Git panel in the sidebar (dsh-git), turning DSH into an MCP server for Claude Desktop and Cursor (dsh-ai-chat-mcp), macOS automation (dsh-automation), and a Windows equivalent with PowerShell and UI Automation (dsh-computer-use). All install by package name without config changes.

The plugin system rests on Cordis, a TypeScript framework providing dependency injection and lifecycle management. Four extension points emerged: Host plugins register tools via ctx.tools.register with plain JSON Schema; Client plugins inject into pre-declared UI slots; Skills are on-demand manuals that load only when needed to save context; and MCP works both ways — DSH can consume external MCP services or serve its own. Sandboxing has three tiers (read-only, workspace-write, danger-full-access), and sensitive operations require approval, while sub-agents isolate large tasks.

Boundaries show up quickly. The capability surface is almost unlimited because plugins are full-permission Node code, but the interaction surface only allows slot injection — core layout and streaming protocol stay closed. Plugins can't be distributed as standalone products. Trust is the hardest limit: a Host plugin runs unsandboxed, so installing third-party code is running arbitrary code. Tool descriptions also bloat context, which is why Skills load lazily. One process hosts everything, so a crashing plugin drags down the app.

Takeaways
— DeepSeek Harness runs its entire agent loop in a single package, dsh-agent-loop; everything else is a replaceable plugin on a Cordis base.
— Five plugins were published to npm: dsh-memory-git (78 tests), dsh-git (20 tests), dsh-ai-chat-mcp (12 tools), dsh-automation (6 macOS tools), dsh-computer-use (Windows PowerShell + UI Automation).
— Memory sync uses pull --rebase; conflicts left it half-applied, so the plugin now rolls back automatically on failure.
— Host plugins register tools via ctx.tools.register; a hello-world example runs in about 15 lines with no SDK and no build step.
— Client plugins inject into pre-declared slots; they cannot alter core layout or streaming rendering.
— Skills show only a one-line summary in context and load full text on demand, preventing tool-description bloat.
— DSH works both as an MCP client (tools prefixed mcp__server__tool) and as an MCP server via dsh-ai-chat-mcp.
— Sandbox levels are read-only, workspace-write, and danger-full-access; missing backend errors out instead of granting access.
— Host plugins run unsandboxed in the main process, so third-party plugins are arbitrary code execution.
— Publishing requires bypassing npm 2FA and pointing at the official registry because npmmirror is read-only.
— engines.dsh declares version admission; mismatches are rejected at the plugin page before install.
Conclusions

The 'self-evolution' claim DSH makes isn't about the model rewriting itself; it's about capabilities persisting as files — plugins in a repo, memory in Git, skills as Markdown — which outlive any single client.

The three-layer abstraction (definition, provider, consumer) is what makes the no-kernel promise credible; swapping a sandbox implementation doesn't force changes in any calling tool.

Treating a plugin as full-permission Node code is both a feature and a liability: extension power scales without ceiling, but trust scales to the same degree.

The real bottleneck for tool-heavy agents is context, not capability; Skills' lazy loading is the workaround that keeps the model from drowning in descriptions.

DSH's plugin model resembles VS Code's extension model more than a browser engine — you can grow tools inside a fixed shell, but you can't grow a new shell.

The author's two-week emphasis on verifying AI-written code around system permissions suggests that agentic coding still requires human judgement at boundaries.

Concepts & terms
Cordis
A TypeScript plugin framework providing dependency injection, scoped services, and lifecycle management; it forms the base of DeepSeek Harness's plugin system.
MCP (Model Context Protocol)
An open protocol for connecting AI assistants to external tools and services; a server exposes tools, and a client can call them with standardized JSON-RPC.
Skills (in DSH)
On-demand operation manuals for the model; only a one-line summary is kept in context, and the full text loads only when the model decides to use it.
Sub-agents
Sessions with independent context that the main agent spawns to handle decomposed subtasks, keeping the main context small and failures isolated.
Seatbelt / bwrap / Landlock
OS-level sandboxing implementations used by DSH's provider layer: Seatbelt on macOS, bwrap (bubblewrap) or Landlock on Linux.
From the discussion
Featured comments
GALer阿青

The tool platform is set, memory cannot be exported, and no entry point for scripts - these three points are exactly why many people switch from cloud agents to local agents: not to make it fancier, but to take back the initiative over capabilities, memory, and scripts. Plugins allow capabilities to grow, which is good; but what truly makes this thing safe to use every day is the boundary: what each plugin can touch, whether to confirm before acting, and whether you can review after it's done. Only when capabilities and boundaries grow together can you trust it.

See top comments, translated →
Source: juejin.cn ↗ Google Translate ↗ Backup ↗