45 Hours After DeepSeek Harness Launched, We Heard 8 Different Voices

Turn the World into a Distributed Harness Team

👦🏻 Author: DeKox

🥷 Editor: Koji

🧑‍🎨 Layout: NCon

Right now, the DeepSeek Harness GitHub repo shows 105,000 Stars and 10,033 Forks.

It's been just 45 hours since release.

Of course, buzz doesn't mean victory. What matters is what developers are actually doing with it.

People are already using DSH to do completely opposite things — some running tests, some filing bugs, some building plugins, others asking "why do we need another harness?"

Forty-five hours after launch, the conversation around DSH is zeroing in on the most critical question of the Agent era:

Beyond the model, who gets to define how Agents work?

Voice 1: The Official Harness Actually Extracts DeepSeek's Capabilities

Programmer Yupi ran four tasks through DSH.

The first was a controlled comparison: building an "attention residual" interactive website. Yupi had previously run the same prompt through DeepSeek V4 Pro + Codex. This time DSH completed it in about 20 minutes with 99% cache hit rate; Yupi judged the connections, animations, summaries, and quizzes to be noticeably better than the previous version.

The second task was a 3D "bamboo cicada" web game supporting both mouse and camera gesture controls. DSH took nearly 40 minutes, cache hit rate approached 100%, and the final product worked.

Total cost for all four tasks: under 5 RMB. This isn't a standardized benchmark, but the same person, same prompt, same model — before and after — at least shows one thing: model capability doesn't automatically become task capability. Tool contracts, context organization, self-checking, and retry logic all change the outcome.

So an Agent's effective capability isn't the Model, it's Model + Harness.

Programmer Yupi's first test: https://www.163.com/dy/article/L4A6PBVO0556DREL.html

Voice 2: Results Are Good, But Absurdly Slow

The same test suite also produced counter-evidence.

Twenty minutes for a website, forty minutes for a 3D game. Yupi explicitly noted that most time was spent on self-checking.

Negative feedback on Xiaohongshu was more direct. Under a "rant about DSH" repost with 443 likes and 329 comments, the top comment was "one bug can take an hour to fix"; another user said two separate hour-long thinking sessions still produced wrong answers.

Cache hit rate solves repeated input pricing, not execution time. Every step — Agent reading files, calling tools, validating results, retrying on failure — extends the chain.

So "more proactive" doesn't equal "more efficient." The metrics that actually matter are: for the same task, what's the success rate, time spent, and total cost?

Xiaohongshu controversy post: https://www.xiaohongshu.com/explore/6a7e0cc6000000002402d6ae

Voice 3: 0.1 Is 0.1 — Strong Skeleton, Skin Still Growing

DeepSeek wrote the warning in all-caps in the README: current version is developer preview, breaking changes will follow.

As of August 15, 8:55 AM, the GitHub Discussions page already shows concrete issues: silent failure with exit code 127 under MSYS2; plugin hot-reload hitting stale module cache; multi-step tasks finished but main branch still showing "in progress"; Windows minimal preset having unapproved writes outside workspace directory.

Latest discussion number is already #1624. The density of problems shows users are actually using it, and that DSH isn't yet a stable production tool.

So DSH 0.1's product value isn't in "already polished," but in whether problems can quickly make it into the next version.

GitHub Discussions: https://github.com/deepseek-ai/deepseek-harness/discussions

Voice 4: "Everything Is a Plugin" Is Both Ceiling and Future Governance Debt

DSH's most important design isn't the Web UI — it's that plugin boundaries extend all the way down to the Agent Loop.

Model, tools, skills, session, sandbox, storage, scheduling, and UI can all be swapped. Tool calls are even split into a pipeline: Hook, approval, permission check, sandbox, timeout, result rewrite, logging, and UI rendering. PTC-generated programmatic tool calls must go through the same approval and sandbox.

The consequences of openness are already visible. Tony Bai found that the official release only provides basic context compression interfaces and naive implementations; on launch day, the community was already building adaptive compression, cross-session memory, and lightweight memory plugins.

But the deeper plugin boundaries go, the harder interface stability, dependency management, version compatibility, performance overhead, and debugging complexity become to control. InfoQ's assessment was direct: developers entering the ecosystem at v0.1 will bear high migration costs.

So "everything is a plugin" isn't a free lunch. DeepSeek opened up innovation space, and also accelerated long-term governance problems.

InfoQ architecture analysis: https://www.infoq.cn/article/de9AljWc4ejW2KAyW8dD

Tony Bai technical breakdown: https://tonybai.com/2026/08/14/deepseek-harness-everything-is-a-plugin/

Voice 5: Do We Really Need Another Harness?

The skeptics have a valid point: Claude Code, Codex, OpenCode, Pi, Hermes already exist — why does DeepSeek need to build another?

On Hacker News, one developer wrote a thin bridge layer and got DeepSeek working through Codex. One stat: cache hit input at 39,123,200 tokens, miss input at 1,692,286 tokens. Their conclusion: mature harnesses already use cache well; a DeepSeek-native harness isn't necessarily needed.

The Xiaohongshu debate is closer to ordinary users. A post "DeepSeek Harness is here, is WorkBuddy doomed?" got 598 likes, 402 saves, 363 comments. Top comments argued they're not on the same layer: WorkBuddy competes on product experience, DSH competes for the runtime between model and application.

So if DSH is just another AI coding product, the market doesn't need a new option; if DSH is an Agent Runtime that other products can adopt, the question becomes "who defines the public interface."

Hacker News discussion: https://news.ycombinator.com/item?id=48257509

Xiaohongshu WorkBuddy discussion: https://www.xiaohongshu.com/explore/6a7dddd30000000032021eb6

Voice 6: Models Can Be Swapped, Harness Is the Long-Term Control Point

The most counterintuitive part: DeepSeek's open-source harness doesn't force you to use DeepSeek models.

The official architecture makes model adapters plugins too. Developers can connect third-party providers and local models. Reddit already has discussions on custom OpenAI-compatible providers, and someone hooked Hermes into DSH, using DSH as a delegated programming engine.

One well-liked Xiaohongshu comment laid out the strategy clearly: models will change, but tools, Session, Memory, Sandbox, sub-Agent scheduling, permissions, and Trajectory will persist; whoever controls the Harness stands between model and application.

So DSH's goal isn't locking users into one model — it's competing for the entry point where models enter real workflows.

Custom model provider discussion: https://www.reddit.com/r/AI_Agents/comments/1vo2f5a/deepseek_harness_got_one_awkward_constraint_right/

Hermes + DSH integration: https://www.reddit.com/r/hermesagent/comments/1voo8pj/hermes_deepseek_harness/

Voice 7: The Agent Race Ultimately Settles on "Complete Task" Accounting

DeepSeek's current official pricing shows V4 Flash at $0.28 per million output tokens, V4 Pro at $0.87.

Starting midnight Beijing time August 17, DeepSwitch to peak-valley pricing. V4 Flash becomes $0.66 off-peak, $1.32 peak; V4 Pro becomes $1.98 off-peak, $3.96 peak.

Price increases don't eliminate DSH's cache advantage, but they amplify the cost of inefficient loops. 99% hit rate looks beautiful; if an Agent burns an extra hour on one error, that beautiful hit rate still becomes a long bill.

So the next phase of price competition won't compare "cost per million tokens" — it will compare: for the same real task, which Model + Harness combination has the highest success rate, shortest time, and lowest total cost.

DeepSeek official pricing: https://api-docs.deepseek.com/quick_start/pricing/

Voice 8: Don't Read It as a Product, It's Actually a Strategy

Koji's read on DeepSeek Harness:

DeepSeek Harness is brilliant! At a time when model capabilities haven't converged, get everyone mobilized, get everyone involved, recruit harness talent from across the world, iterate together and explore uncharted territory. Don't read this as a product, it's actually a strategy.

The official contribution guide sends the same signal.

The DSH guide also states: packages in the official repo aren't inherently more important than community packages; the official repo is an idea, a demonstration and source of inspiration, not a standard answer the community must obey.

This arrangement isn't about outsourcing development tasks to the community — it's about expanding exploration bandwidth.

When model capabilities haven't converged, Agent architecture has no standard answer. How should memory be compressed, when to call sub-Agents, whether tools should be called sequentially or programmed then executed — a single team can only test limited combinations.

A plugin ecosystem lets global developers try different answers in parallel.

So every plugin is a hypothesis, every task execution is an experiment, every bug exposes a capability boundary. DeepSeek expanded its internal Agent R&D into a public, parallel experiment.

DeepSeek Harness contribution guide: https://github.com/deepseek-ai/deepseek-harness/blob/master/CONTRIBUTING.md

Final Words

Forty hours after release, eight voices haven't reached consensus — but they've drawn a clear line.

Read DSH as a product, the conclusion is: slow, rough, buggy, still far from a mature tool.

Read DSH as infrastructure, the conclusion is: 98,900 Stars, 9,255 Forks, latest discussion #1624, memory and compression plugins appearing on launch day — the public experiment is already running.

Buzz only proves attention, not strategic success. Next, watch three hard metrics: success rate, time, and total cost for the same real task; survival rate of third-party plugins across breaking upgrades; speed at which community issues make it into new releases.

The core argument is therefore clear:

DeepSeek didn't open-source another Coding Agent — it open-sourced a distributed R&D mechanism for global developers to jointly find the optimal Agent solution.

On August 13, DeepSeek handed the question "how should the next-generation Agent work" to global developers.

🎪

Crossing will host an online closed-door Agent Harness sharing session on Thursday, August 20, starting from observations and reflections brought by DeepSeek Harness.

Researchers, engineers, and entrepreneurs interested in the Agent Harness space are welcome to join.

Scan to register.