DeepSeek Harness vs Claude Code: Which Coding Agent Fits Your Stack?

DeepSeek Harness (dsh) landed on August 13, 2026, and the framing was impossible to miss. VentureBeat’s launch headline called it an “open source rival to Claude Code,” shipping alongside DeepSeek V4-Pro on the API. One week later, the repo sits at roughly 169k stars (as of August 20). That’s a loud arrival.

But star counts don’t answer the question developers actually have: should I run my coding agent on DeepSeek Harness or Claude Code? The two tools make different bets. One is an MIT-licensed developer preview built around a plugin kernel and a local web UI. The other is a proprietary, mature product with a deep ecosystem: skills, hooks, native MCP, subagents, and five surfaces to run it on.

This comparison walks through the dimensions that matter: licensing, interface, model freedom, pricing, maturity, extensibility, permissions, and MCP. No invented benchmarks, no vibes-based performance claims. Just what each tool verifiably does today. If you’re new to dsh, start with what DeepSeek Harness is and how it works, then come back.

The quick comparison

Now the details, because the table hides most of the interesting parts.

Open source vs proprietary: what MIT actually buys you

DeepSeek Harness is MIT licensed, with third-party dependencies tracked in THIRD_PARTY_NOTICES.md. That’s about as permissive as licensing gets. You can read the agent loop, fork it, patch it, embed it in a commercial product, and audit exactly what it sends over the wire. For teams with strict compliance requirements, or anyone burned by a vendor deprecating a feature they depended on, that transparency is the headline feature.

Claude Code is the opposite. The LICENSE file in Anthropic’s public repo reads “© Anthropic PBC. All rights reserved. Use is subject to Anthropic’s Commercial Terms of Service.” The GitHub repo exists for issues and docs, not source. You get a polished binary and a contract, not code you can inspect or fork.

Does that matter? It depends on who you are. A solo developer mostly cares whether the tool works. A platform team embedding an agent into internal tooling cares a lot: MIT means dsh can become infrastructure, while Claude Code stays a product you subscribe to. The honest counterweight is that open source only pays off if the project stays maintained, and dsh is seven days old. MIT is a promise about rights, not longevity.

Interface: local web UI vs go-anywhere

dsh takes an unusual route for a “CLI” agent. The quick start is npx @deepseek-ai/dsh web, which starts a local web UI at http://127.0.0.1:3080 and opens your browser (pass --no-open to skip that). You pick a workspace, point it at the project directory where you launched dsh, and work from the browser. It’s local-first: the UI is served from your machine, not a hosted service.

Beyond the web UI, dsh’s CLI README documents profile-based entry modes: dsh --profile <name> boots a named profile under $DSH_HOME/profiles/<name>, and a headless profile runs one persisted session, prints the final answer, and exits. dsh web is itself just shorthand for the web profile, and dsh plugin manages a profile’s plugins by forwarding to pnpm. So scripting and automation are possible, but the web UI is clearly the front door.

Claude Code started terminal-first and sprawled from there. Per the official docs, it now runs in the terminal, as VS Code and JetBrains extensions, as a standalone desktop app, and in the browser at claude.ai/code, with mobile support. Sessions move between surfaces. The headless story is mature too: claude -p "prompt" pipes into CI, cron, and shell pipelines.

If you live in one project on one machine, dsh’s local web UI is a pleasant, low-setup experience. If you bounce between an IDE, a terminal, CI, and your phone, Claude Code’s surface coverage is in a different league right now.

Model freedom: the sharpest philosophical split

This is the dimension where the two tools genuinely disagree about what a coding agent should be.

dsh is model-agnostic by design. Its provider docs ship catalog providers for Anthropic, OpenAI, Bedrock, Vertex, and Azure, and let you register any OpenAI-compatible endpoint in $DSH_HOME/settings.yaml: set apiKeyEnv, api: openai-completions, a baseURL, and a model list, and the harness treats it like any other backend. API keys live in a separate .credentials.yaml, so your settings file stays shareable. That means dsh can drive DeepSeek’s own models, a rival lab’s API, or a quantized model on your own GPU through a local server. We cover the full setup in how to run any model in DeepSeek Harness.

Claude Code runs Claude models. Full stop. You can route inference through Amazon Bedrock, Google Cloud’s Agent Platform, or Microsoft Foundry instead of Anthropic’s API, but those are billing and infrastructure choices; the model is still Claude. Anthropic’s position is that the harness and the model are co-developed, and tight integration beats flexibility.

Neither position is wrong. Model lock-in stings when prices move or a better model ships elsewhere. Tight coupling pays off when the vendor tunes the agent loop and the model together. Pick based on how much you value the exit door.

Pricing: per-token vs subscription

The dsh harness itself is free. What you pay for is inference on whatever API you connect. If that’s DeepSeek’s own API, you pay DeepSeek’s per-token rates; note that V4-Pro, which launched the same day as dsh, arrived with higher prices than its predecessors, per VentureBeat’s launch coverage. Our guide to the DeepSeek V4-Pro-0813 API covers the model IDs and request formats if you go that route. Per-token pricing is transparent and scales to zero when you’re not coding, but heavy agentic sessions can chew through tokens unpredictably, and there’s no flat ceiling.

Claude Code inverts that. Most users run it on a Claude Pro ($20/month) or Max ($100 or $200/month) subscription, with usage-based API billing through the Claude Console as the alternative for teams that prefer it. Subscriptions give you a predictable bill with usage limits rather than a meter, and those limits have been a live topic: Anthropic raised weekly limits by 50 percent in July 2026, which we broke down in our coverage of the Claude Code weekly limits increase.

Rough rule: light or bursty use tends to favor per-token; daily heavy use tends to favor a flat subscription. And since dsh can also point at Anthropic’s API through its catalog provider, the pricing question is partly orthogonal to the harness question.

Maturity: seven days vs an ecosystem

Here’s where honesty requires bluntness. DeepSeek Harness is a developer preview, and its own README says, verbatim: “THERE WILL BE COMPATIBILITY-BREAKING CHANGES.” That’s not a hedge, it’s a promise. Configs you write today may not parse next month. Plugins may need rewrites. The docs still have gaps; several referenced pages are thin or in flux. If you build workflows on dsh right now, you’re signing up to maintain them through churn.

Claude Code has been in developers’ hands since early 2025, and the production hardening shows in the surface area: CLAUDE.md project memory, auto memory, skills for packaged workflows, hooks that run shell commands around agent actions, subagents with a coordinating lead agent, an Agent SDK for building custom agents, GitHub Actions and GitLab CI/CD integrations, and scheduled routines. None of that is exotic anymore; it’s documented, versioned, and in daily use. We compared it against another mature rival in Claude Code vs Codex CLI, and the ecosystem depth was decisive there too.

The counterpoint: dsh’s trajectory is steep. Roughly 169k stars and 18.1k forks in a week (as of August 20) means an unusual amount of community energy, and community ecosystems can close feature gaps fast. But today, “preview” vs “product” is the accurate framing.

Extensibility: plugin kernel vs plugin ecosystem

Both tools are extensible. They differ in where extensibility lives.

In dsh, plugins aren’t an add-on layer; they’re the architecture. The harness is built on Cordis, a plugin kernel whose design is described in the paper “A Programming Paradigm for Spatiotemporal Composability.” The model adapter, tool registry, session log, and even the agent loop itself are replaceable plugins. If you dislike how the agent loop retries failed tool calls, you can swap the loop. Community plugins are discovered via the dsh-plugin GitHub topic, and unofficial projects (desktop wrappers, context managers, vision routers) are already multiplying.

Claude Code exposes extension points rather than internals: plugins, skills, hooks, MCP servers, and subagents let you customize behavior at well-defined seams, but the core loop is Anthropic’s. For most teams that’s plenty, and the guardrails mean an upgrade rarely breaks your customizations. For tinkerers who want to rebuild the engine, dsh is the only one of the two that even offers a wrench.

Permissions: policy prompts vs six modes

An agent that edits files and runs commands needs brakes.

dsh’s web UI asks before operations “that require approval under the active permission policy,” per its user guide. That’s the verified extent of what’s documented publicly today; the policy levels and their exact semantics aren’t yet spelled out in the guide index, which is itself a symptom of preview-stage docs.

Claude Code’s permission system is documented to an almost bureaucratic degree: six modes (default, acceptEdits, plan, auto, dontAsk, bypassPermissions), fine-grained allow/deny rules per tool and command, working-directory boundaries, and managed policies admins can enforce org-wide. plan mode lets the agent explore without editing; auto mode reviews actions with a background classifier instead of prompting you; bypassPermissions exists for sandboxed containers.

If permission granularity is a requirement (regulated codebase, junior-heavy team, CI autonomy), Claude Code is measurably ahead on documentation and controls today.

MCP: native vs community plugin

Model Context Protocol is how coding agents reach external systems: databases, ticket trackers, API specs. Claude Code supports MCP natively; connecting a server is a first-class, documented flow, and MCP tools plug into the same permission rules as everything else.

In dsh, MCP support is not part of the core today. What exists is a community plugin, dsh-mcp-manager, which adds a Settings page for MCP, supports remote HTTP and local stdio servers, handles OAuth or static tokens, and registers tools as mcp__<name>__*, with per-project server configs. It works, but it’s community-maintained, not official, and it inherits the preview-era churn risk. Given dsh’s plugin-first architecture, first-party MCP wouldn’t be surprising later; it just isn’t there now.

This matters for API work specifically. The Apidog MCP Server gives a coding agent direct access to your team’s actual API specification, so it generates client code against the real contract instead of hallucinating field names. With Claude Code that connection is native. With dsh it routes through the community plugin. Either way, the agent that can read your tested spec writes better API code, and you can download Apidog and run its MCP server against the same project both agents work on. Pair that with Apidog CLI regression runs in CI and you have the same safety net under whichever agent wins your evaluation.

Which one should you pick?

There’s no single winner here, because the two tools are making different bets at different maturity stages.

Pick DeepSeek Harness if:

• You need the source. MIT licensing, auditability, and forkability are hard requirements for some teams, and dsh is the only one of the two that offers them.
• You refuse model lock-in. One harness driving DeepSeek, OpenAI-compatible local models, and catalog cloud providers is dsh’s genuine structural advantage.
• You’re a tinkerer. The Cordis everything-is-a-plugin design rewards people who want to reshape the agent itself.
• You can tolerate breakage. The README’s warning is explicit, and you should believe it.

Pick Claude Code if:

• You want a finished product. Five surfaces, mature docs, and an ecosystem of skills, hooks, subagents, and native MCP that dsh simply hasn’t had time to grow.
• You need enterprise controls. Documented permission modes, managed policies, and cloud-provider routing are shipping features, not roadmap items.
• Predictable billing matters. A Pro or Max subscription caps your exposure in a way per-token billing doesn’t.
• You’re happy with Claude models, because that’s the deal.

A pragmatic middle path: many developers will run both for a while. dsh costs nothing to try (npx @deepseek-ai/dsh web and you’re in), and Claude Code’s subscription doesn’t preclude experiments. Whichever you land on, keep the API layer honest with Apidog: one tested spec, served to either agent over MCP, verified by CLI regression runs after every agent-written change.

FAQ

Is DeepSeek Harness actually open source, unlike Claude Code?

Yes. dsh is MIT licensed with its source on GitHub, including the agent loop and plugin kernel. Claude Code’s public repo carries an all-rights-reserved notice under Anthropic’s Commercial Terms; it hosts issues and docs, not source code you can fork.

Can DeepSeek Harness use Claude models?

Yes. dsh ships catalog providers for Anthropic, OpenAI, Bedrock, Vertex, and Azure, plus custom OpenAI-compatible endpoints via settings.yaml. The reverse isn’t true: Claude Code runs Claude models only, whether direct from Anthropic or through Bedrock, Vertex, or Foundry.

Is DeepSeek Harness stable enough for daily work?

It’s a developer preview, and the README warns in capital letters that there will be compatibility-breaking changes. It’s absolutely usable for real work, but expect config and plugin churn. Claude Code is the safer choice for workflows you can’t afford to rebuild.

Do both agents work with Apidog?

Yes. Apidog’s MCP server exposes your API spec to any MCP-capable agent: natively in Claude Code, and via the community dsh-mcp-manager plugin in dsh. The Apidog CLI also runs scripted regression tests in either agent’s terminal loop; we walk through the dsh setup in using Apidog CLI in DeepSeek Harness.