DSH HUB
HomePlugin StorePlugin PacksCommunityRankingsResourcesPublish Guide
Plugin source
Back to catalog

Echoes-fade /

Echoes-fade/deepi-harness

Topic repository only

Deep Pi Harness — 极简 AI 智能体客户端:四工具内核(读/写/改/跑命令)+ 完整插件面板。微光即星海 · 简单内核万象世界

★ 0 Stars0 Forks0 IssuesN/A Community rating0 Confirmed installs
View on GitHub
READMESource: main@11bbf7dd

Deep Pi Harness

Deep Pi mark

A glimmer is a sea of stars · A simple core, a world of everything

Deep Pi Harness is an agent client built for writing code: DSH's skeleton and interface, pi's core and philosophy. The model sees four tools — read, write, edit, run a command.

English | 中文

This is not a pi fork. We did not port a single line of pi, and pi's extension ecosystem will not load here — the reason is in our weaknesses.

Why this project exists

Let me start with my own part, because every trade-off below comes from it.

For a long time I was infatuated with all-in-one. Aggregated apps, universal tools, "I may not use it, but I can't be without it". So I liked DSH's architecture on sight: everything is a plugin, deeply customisable, an almost endless shelf of tools.

But more of anything always turns into a mess. I once ran DSH at high intensity for a couple of weeks, then sat down and counted: half my tokens went into fixing bugs, writing plugins and repairing compatibility. My own output barely moved.

Then I met pi. Fresh out of the maximalist world, I fell for the minimal one immediately: an environment with only read / write / edit / bash, like being a child again — nothing to consider all day, just plain reading, writing, listening, speaking.

It did not take long to hit the inconvenience. Switching models in a terminal means typing commands. Lots of commands to learn from scratch. No GUI. I tried a few community GUIs; immature behaviour, plenty of bugs.

Around then I kept asking myself one thing: why do I have to use someone else's tool? Why can't I build my own?

The first idea was DSH's creation mode — write a pi-like minimal preset myself. That does not solve anything: the model only reaches four tools, but you still reach hundreds of plugins. You are still living in the maximal world.

So I changed direction: delete plugins. Delete everything I do not use. And while deleting, a question appeared — could I make this DSH world almost identical to pi?

What followed was a long stretch of architecture work, vibe coding, carefully weighed persona prompts and a plugin list picked one row at a time. What you see is the result: original DSH skeleton, the official ecosystem still reachable, a far more mature UI and interaction model — plus a pi-style core. Minimal prompt, almost no tools, very few tokens, and model behaviour inside this frame that tracks pi closely (our own estimate: over 95%).

First, what DSH and pi actually are

DSH (DeepSeek Harness)

DeepSeek's official agent client — a desktop app, with a Web form as well. Its design in one line: everything is a plugin. Three hundred-plus packages, forty-four model-visible tools, ninety-two UI mount points; sessions, the plugin panel, settings, permissions, sandbox, subagents, MCP, Skills, all inside. The engineering is strong, and prompt caching in particular is done properly: the system prompt is a stable prefix, the prefix holds as long as the tool set holds, and long sessions hit cache heavily.

The pain points are just as clear — mine, at least:

  • Too much. Three hundred plugins laid out flat, with nothing telling you which are foundations and which are decoration. Turn one off and you cannot tell what breaks.
  • A high entry fee. You have to understand presets, profiles and plugin layering before you dare touch the config.
  • Instability. This part is subjective, but my experience: behaviour shifts between rcs, and plugins fail quietly — an executor registers successfully while the tool never resolves, no error, just silently missing.
  • It takes your attention along with the convenience. Every capability is mounted by default, so the model has a wide menu and scattered attention.

pi

A minimal command-line coding agent. Its world is four things: read a file, write a file, edit a file, run a command. The system prompt is short enough to memorise, the tool schemas take a sliver of context, and all of the effort goes into finishing the job.

The advantages are real: almost no entry fee (install it and go, nothing to configure), very high runtime efficiency (small context, light requests, cheap tokens), focused attention (few tools, no wandering).

The shortcomings are just as real:

  • No mature client. The terminal is the only real home; switching models or tuning parameters means typing commands; the community GUIs are immature, buggy and inconsistent.
  • Bare. Four tools and that is it. Search, subagents, Skills, a proper interface — all of it means hand-rolling extensions and owning whatever compatibility damage that brings.
  • Everything by hand. No sidebar, no file panel, no drag-and-drop attachments; the interaction lives in your keyboard and your memory.

The two sets of pain points complement each other

DSH's problem is "too much". pi's problem is "too little". DSH lacks constraint; pi lacks a shell. So this project is neither "another layer on DSH" nor "a copy of pi" — it is one side's core moving into the other side's mature shell.

What we actually did

The skeleton we kept, untouched: the desktop client itself, sessions and sidebar, settings, the plugin panel, permissions and sandbox, attachments, shortcuts, themes, ninety-two UI slots, and the whole plugin loader. An upstream plugin only depends on four contracts (service names, slot names, tool schemas, event names), and those work here exactly as before — we did not change one of them.

The core we replaced, aligned item by item with pi:

Item Official default Here
Model-visible tools Forty-four Four: read / write / edit / bash
System prompt Assembled in sections, includes runtime context One paragraph (about 70 words), owns the prompt, no per-request content injected
Context compaction Standard thresholds Aligned with pi: headroom 16384, retain 20000, max 32768
Instruction files AGENTS.local.md and friends pi's order: AGENTS.override.md → AGENTS.md → CLAUDE.md
Tool-output spill Official spill policy, default threshold Tightened to 10000 tokens, inline keeps "head + gap + tail + spill path"
Repeat-call reminder All tools, thresholds 3/5/8 bash only, thresholds 6/10/14
Plugins mounted by default The whole official preset A minimal set; the rest are off and one click away

One thing we found while deleting: DeepSeek's core is genuinely well built — we stripped the plugin set down this far and the plugin ecosystem barely noticed. That is not our achievement; it is their layering being clean. All we did was make the judgement call they left to you.

What the two slogans actually say

They are not wishes. They are two product constraints.

A glimmer is a sea of stars. One point of light is the ocean. In plain words: the smallest possible context is enough to finish almost all real work. We do not prove ourselves by how much we ship; we prove ourselves by how much we can switch off and still work. Four tools, a one-paragraph prompt, a stable prefix — every request small, fast, cache-hitting. That is the glimmer; the workload it covers is the sea.

A simple core, a world of everything. The core is simple, and you still get the whole world. What is simple is the core, not the possibilities: the core has four tools, but you want search, you switch search on; you want subagents, you switch subagents on; you want Office, voice, MCP, you install them. Install what you need, when you need it — instead of having "everything" decided for you on day one.

Three products side by side

DSH (official) pi Deep Pi Harness
Interface Mature desktop GUI + Web Terminal DSH's mature desktop GUI
Tools Forty-four, all mounted Four Four
Prompt Sectioned, long Very short Very short (one paragraph)
Entry cost High (plugin layering to learn) Low Medium (command line + one config pass)
Extensibility Very strong, but you must curate Hand-rolled extensions Very strong, and off by default
Ecosystem Official + third-party plugins pi extensions DSH ecosystem (pi extensions not yet)
Context overhead Large Tiny Tiny
Cache hits Good Good Good (shorter, steadier prefix)
Built for People who want one-stop Terminal purists / minimalists People writing code

Where our advantages actually are

In one sentence: pi's speed, DSH's ecosystem and shell. You used to have to pick one; here both are present.

  1. Focused attention, clean context. Every turn the model faces four tools and a short prompt. Fewer tools is not only about tokens — it also means the model does not have to choose among forty-four options, so behaviour stays steadier and closer to "read it, change it, run it to verify".
  2. High cache hit rate, and it really is faster. Stable prefixes are DSH's strong suit: the tool set does not change, the prompt does not change, nothing like a clock or workspace path gets injected. We kept that property intact, and because the prompt is shorter the prefix is smaller and easier to hit in full. In practice: lower time-to-first-token, less slowdown on long sessions, smaller bills.
  3. pi's behaviour, DSH's shell. The same four-tool logic, wrapped in a mature desktop application: session list, files, attachments, shortcuts, themes, settings, the plugin panel, permission prompts. pi users no longer have to choose between "the terminal that never changes" and "the community GUI that isn't ready".
  4. Extensibility without the clutter. Need a capability, open the plugin panel and install it; no more agonising over which of the original three hundred to enable, which to disable, and what breaks if you do. The default is clean, the extension is explicit.
  5. "Everything is a plugin" is intact. Our subtraction happens in the defaults, not in the architecture. You can mount search, subagents, Skills, Office, voice back at any time, or write a plugin only you will ever need — none of the four contracts upstream plugins rely on was touched.
  6. The safety that actually saves you is still here. Read before write (you must have read a file before changing it; if someone else changed it in between, no silent overwrite), approval and sandbox (default workspace-write; writing outside the workspace needs your nod), automatic compaction, spill-to-disk fallback for large tool output.

Our weaknesses, stated plainly

  • Few built-in tools, few plugins. Four tools means four tools; if it is not mounted, it really is not there. If you want "one app that does everything", this will hurt. It is not built for absolute beginners, and not for general everyday use.
  • Not a beginner's tool. You need to be comfortable with the command line, willing to touch a profile config once, and clear on the fact that plugins start off. We optimise for the efficiency of people who already work this way, not for a zero-baseline first run.
  • Not a general-purpose daily assistant. It is designed for writing code, running commands, changing repositories. Documents, spreadsheets, email, voice input are not default capabilities; you enable them yourself.
  • pi's ecosystem does not connect. We are DSH's skeleton plus pi's philosophy, and still DSH underneath. pi's extensions (pi-package) cannot be loaded yet — that needs a compatibility layer, and there isn't one.
  • No prebuilt installer yet. Today you install Node 24, run pnpm run build and package it yourself (macOS Apple Silicon verified; Windows compiles from the same upstream code but is untested here).
  • The bundle is close to 1 GB. The Office engine, Python and the speech engine are all still in the package — just not mounted. The slimming investigation is done; the removal is not.
  • Early stage. Compatibility-breaking changes will happen; following upstream rcs means rebasing, one version at a time. Read the safety notice first.
  • The plugin panel cannot reach everything. Rows inside an agent preset are read-only, and rows with conditional expressions must be edited in the config file.

Getting started

Prerequisites

  • Node.js 24 (not 26), pnpm 11
  • A working model: an OpenAI-compatible endpoint and key, entered in Settings

Build from source

git clone https://github.com/Echoes-fade/deepi-harness.git
cd deepi-harness
pnpm install --frozen-lockfile
pnpm run build

Run the Web form directly:

pnpm dsh web

Package the desktop app (macOS Apple Silicon, unsigned):

pnpm run package:desktop:mac:arm64:unsigned

The artifact lands in apps/desktop/.desktop-build/targets/mac-arm64/unsigned-artifacts/mac-arm64/Deep Pi.app.

Apply the pi preset

The repository gives you the shell (a complete DSH client); the four-tool core lives in the profile config — cordis.patch.yml inside that profile (by default ~/.dsh/profiles/<profile>/cordis.patch.yml). With it applied, the model's world shrinks to those four tools.

For what each tier keeps, what is off, and what breaks when you switch something off, read the plugin tier plan. Build environment, known traps and how we follow upstream are in AGENTS.local.md.

Ecosystem and compatibility

A third-party plugin depends on exactly four things: cordis service names and interfaces, slot names and children declarations, tool schemas, event names. We changed none of them, so upstream plugins work here as usual. The few edges we did touch are documented in docs/dee-pi/ecosystem-compat.md.

Upstream and credit

  • DSH (DeepSeek Harness), MIT. The shell, the plugin system, the cache design and most of the code come from it. Baseline: dsh-v0.2.1-rc.5.
  • pi (@earendil-works/pi-coding-agent). What we borrowed is its philosophy and behavioural targets — four tools, a very short prompt, compaction parameters, instruction-file order. No code was used.
  • The brand mark is a whale: DeepSeek's outline in pi's three colours.
  • Community: plugin and architecture questions belong in the upstream Discussions; issues and PRs for this custom build go to this repository.

Development

Changing apps/desktop/, the profile config, or writing a standalone plugin is straightforward. Before touching packages/, read AGENTS.local.md: it holds this repository's rules, one worktree per change, the build and packaging environment, and the traps already hit. A build takes about 3 minutes, packaging about 5, and both need Node 24.

Citation

@misc{deepseek-harness2026,
  title={[DSH]: Everything is a Plugin},
  author={DeepSeek-AI},
  year={2026},
  publisher={GitHub},
  howpublished={\url{https://github.com/deepseek-ai/deepseek-harness}},
}

License

MIT

Third-party dependencies and their licenses are disclosed in THIRD_PARTY_NOTICES.md.

—/ 5

No ratings yet

Manifest verification required

Commit 11bbf7dd1a63

Community comments

No comments yet. Be the first to write one.

DSH HUB

A community index for DSH plugins. Not an official GitHub or DeepSeek AI product.

CommunityResourcesAPIAbout