Hassann

Posted on Aug 20 Originally published at apidog.com

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

DeepSeek Harness (dsh) landed on August 13, 2026, framed as an open-source alternative to Claude Code. VentureBeat’s launch coverage described it as an “open source rival to Claude Code,” released alongside DeepSeek V4-Pro on the API. One week later, the GitHub repository had roughly 169k stars as of August 20.

Try Apidog today

Stars do not answer the implementation question: should you run your coding workflows with DeepSeek Harness or Claude Code?

The tools make different trade-offs:

DeepSeek Harness: MIT-licensed developer preview, plugin-kernel architecture, local web UI, and multiple model providers.
Claude Code: proprietary, mature coding agent with native MCP, skills, hooks, subagents, permission controls, and multiple interfaces.

This guide compares licensing, setup, model configuration, pricing, maturity, extensibility, permissions, and MCP support. It avoids unverified performance claims. If you are new to dsh, start with what DeepSeek Harness is and how it works.

💡 Both agents write code against APIs, and the output quality depends on the API contract you provide. Keep your specification tested and current with Apidog, whichever agent you choose.

The quick comparison

Dimension	DeepSeek Harness (dsh)	Claude Code
License	MIT, source on GitHub	Proprietary; “All rights reserved,” Anthropic Commercial Terms
Age	Released Aug 13, 2026; developer preview	Generally available, mature product
Stability	README warns of compatibility-breaking changes	Stable release channels, versioned settings
Interface	Local web UI at `127.0.0.1:3080`, plus profile-based CLI modes including headless	Terminal CLI, VS Code, JetBrains, desktop app, web, and mobile
Models	DeepSeek, catalog providers for Anthropic, OpenAI, Bedrock, Vertex, Azure, and OpenAI-compatible endpoints	Claude models only, direct or through Bedrock, Vertex, or Foundry
Pricing	Free harness; pay per token for the API you connect	Claude Pro/Max subscription or usage-based API billing
Extensibility	Everything is a plugin through the Cordis kernel	Plugins, skills, hooks, subagents, Agent SDK
Permissions	Web UI approval prompts under an active permission policy	Six documented modes plus allow/deny rules
MCP	Community plugin: `dsh-mcp-manager`	Native, first-class support

Open source vs proprietary: what MIT changes

DeepSeek Harness is MIT licensed, with third-party dependencies listed in THIRD_PARTY_NOTICES.md. In practical terms, you can:

Inspect the agent loop.
Audit what the harness sends over the network.
Fork and patch the project.
Embed it in commercial internal tooling.
Replace parts of the implementation through plugins.

That matters when source access, auditability, or vendor independence is a requirement.

Claude Code takes the opposite approach. Its public repository is for issues and documentation. Its license states:

© Anthropic PBC. All rights reserved. Use is subject to Anthropic’s Commercial Terms of Service.

You use a supported product and its documented extension points, but you cannot inspect or fork the core implementation.

A practical decision rule:

Choose dsh if the agent must become part of your infrastructure.
Choose Claude Code if you prefer a supported product over maintaining agent internals.

MIT licensing gives you rights, not maintenance guarantees. dsh is still a developer preview.

Interface: local web UI vs multiple surfaces

Start DeepSeek Harness

The dsh quick start launches a local browser interface:

npx @deepseek-ai/dsh web

This starts the UI at:

http://127.0.0.1:3080

To start the server without opening a browser automatically:

npx @deepseek-ai/dsh web --no-open

From the UI, select the workspace that maps to the directory where you launched dsh.

dsh also supports profile-based CLI execution. According to the CLI README, profiles live under:

$DSH_HOME/profiles/<name>

Launch a profile with:

dsh --profile <name>

A headless profile can run a persisted session, print the final response, and exit. This makes automation possible, although the web UI is currently the primary interface.

Plugin management is also profile-scoped:

dsh plugin

This forwards plugin operations to pnpm.

Run Claude Code where you work

Claude Code supports more execution surfaces. Per the official overview, you can use it in:

Terminal
VS Code
JetBrains IDEs
Desktop app
Browser at claude.ai/code
Mobile

For non-interactive scripts, CI, cron jobs, or shell pipelines:

claude -p "prompt"

Use dsh when a local browser workflow fits your project. Use Claude Code when you need to move between IDEs, terminals, web sessions, CI, and mobile.

Model freedom: configure any supported backend in dsh

This is the clearest architectural difference.

dsh is model-agnostic. Its provider documentation includes catalog providers for:

Anthropic
OpenAI
Amazon Bedrock
Google Vertex
Azure

It also supports any OpenAI-compatible endpoint through $DSH_HOME/settings.yaml.

A provider configuration includes:

apiKeyEnv: MY_PROVIDER_API_KEY
api: openai-completions
baseURL: http://localhost:8000/v1
models:
  - name: my-local-model

Keep API credentials in a separate .credentials.yaml file so you can share settings without committing secrets.

This lets dsh work with:

DeepSeek APIs
Anthropic APIs
Hosted OpenAI-compatible APIs
Local model servers
Quantized models running on your own GPU

For a full walkthrough, see how to run any model in DeepSeek Harness.

Claude Code runs Claude models only. You can use Amazon Bedrock, Google Cloud’s Agent Platform, or Microsoft Foundry for infrastructure and billing, but the underlying model remains Claude.

Use dsh when model portability is important. Use Claude Code when you want a tightly integrated Claude-specific agent experience.

Pricing: token billing vs subscriptions

The DeepSeek Harness software itself is free. You pay for inference from whichever provider you configure.

If you use DeepSeek’s API, pricing follows DeepSeek’s per-token rates. VentureBeat reported that V4-Pro, released with dsh, had higher pricing than earlier models.

To call V4-Pro directly, review the DeepSeek V4-Pro-0813 API guide.

Per-token billing works well when usage is light or bursty:

No coding sessions = no inference charges

The trade-off is that long agentic sessions can use an unpredictable number of tokens.

Claude Code is commonly used through:

Claude Pro: $20/month
Claude Max: $100/month or $200/month
Usage-based API billing through the Claude Console

Subscriptions make costs more predictable, although they include usage limits. Anthropic raised weekly limits by 50% in July 2026; see the Claude Code weekly limits increase coverage.

A useful rule of thumb:

Light or intermittent use: per-token pricing may be cheaper.
Daily, heavy use: a subscription may be easier to budget.

Because dsh can connect to Anthropic’s API, the model provider and harness decision can be evaluated independently.

Maturity: developer preview vs established ecosystem

DeepSeek Harness is explicitly a developer preview. Its README states:

THERE WILL BE COMPATIBILITY-BREAKING CHANGES.

Plan accordingly:

Pin your configuration where possible.
Expect settings and plugins to change.
Test upgrades in a non-production workspace.
Avoid building critical workflows without a maintenance plan.

Claude Code has been available to developers since early 2025. Its ecosystem includes:

CLAUDE.md project memory
Auto memory
Skills for reusable workflows
Hooks that run commands around agent actions
Subagents coordinated by a lead agent
Agent SDK
GitHub Actions integration
GitLab CI/CD integration
Scheduled routines

These features are documented and versioned. For another comparison of ecosystem maturity, see Claude Code vs Codex CLI.

dsh has substantial early community activity, with roughly 169k stars and 18.1k forks in its first week as of August 20. That can accelerate plugin development, but it does not remove preview-stage risk.

Extensibility: plugin kernel vs extension points

Both tools are extensible, but at different layers.

DeepSeek Harness: plugins are the architecture

dsh is built on Cordis, a plugin kernel described in the paper A Programming Paradigm for Spatiotemporal Composability.

In dsh, components such as these are replaceable plugins:

Model adapters
Tool registries
Session logging
Agent loop behavior

For example, if you need custom retry behavior for failed tool calls, dsh’s architecture allows you to replace the relevant loop component instead of waiting for a vendor feature.

Discover community packages through the GitHub dsh-plugin topic.

Claude Code: stable extension seams

Claude Code exposes supported extension points:

Plugins
Skills
Hooks
MCP servers
Subagents

You customize behavior without replacing the core agent loop. This is usually safer for teams that prioritize upgrade stability.

Choose dsh if you need to reshape the engine. Choose Claude Code if documented customization points are sufficient.

Permissions: approval prompts vs six documented modes

Coding agents need controls before they edit files, execute commands, or access external services.

dsh’s web UI asks for approval when an operation requires it under the active permission policy. That behavior is documented, but the public documentation does not yet define all policy levels and semantics in detail.

Claude Code’s permission system documents six modes:

default
acceptEdits
plan
auto
dontAsk
bypassPermissions

It also supports:

Fine-grained allow and deny rules by tool or command
Working-directory boundaries
Organization-managed policies
plan mode for exploration without edits
auto mode using a background classifier to review actions
bypassPermissions for sandboxed containers

For regulated repositories, junior-heavy teams, or autonomous CI jobs, Claude Code currently has more documented controls.

MCP: native support vs a community plugin

Model Context Protocol (MCP) lets coding agents access external systems such as databases, ticket trackers, and API specifications.

Claude Code supports MCP natively. MCP servers are a first-class, documented integration, and their tools use the same permission model as other agent actions.

In dsh, MCP is currently provided through the community-maintained dsh-mcp-manager plugin. It provides:

A settings page for MCP configuration
Remote HTTP server support
Local stdio server support
OAuth or static-token authentication
Per-project server configuration
Tool registration with names such as:

mcp__<name>__*

This works, but it is not core functionality and carries community-plugin and preview-stage maintenance risk.

Use Apidog as the API contract layer

For API-focused work, connect your agent to the real API contract instead of relying on generated assumptions.

The Apidog MCP Server gives an MCP-capable coding agent access to your team’s API specification. That helps the agent generate client code against actual endpoints, fields, and schemas.

In Claude Code, connect Apidog through native MCP support.
In dsh, connect it through dsh-mcp-manager.

You can also download Apidog and run its MCP server against the same project directory used by either agent.

A practical workflow looks like this:

Maintain the API specification in Apidog.
Expose it to the agent through MCP.
Ask the agent to implement or update API client code.
Run Apidog CLI regression tests in CI.
Review generated changes before merge.

The same API test suite can validate changes produced by either agent.

Which one should you pick?

There is no universal winner. The right choice depends on your constraints.

Pick DeepSeek Harness if

You need source access, MIT licensing, auditability, or forkability.
You want to use multiple model providers from one harness.
You need OpenAI-compatible local model support.
You want to modify agent internals through plugins.
You can tolerate configuration and plugin churn.

Start with:

npx @deepseek-ai/dsh web

Then test it in a non-critical repository before standardizing on it.

Pick Claude Code if

You need a mature product now.
You work across terminal, IDE, desktop, browser, mobile, and CI.
You require documented enterprise permission controls.
You depend on native MCP integration.
You prefer predictable subscription-based billing.
You are comfortable standardizing on Claude models.

Consider running both during evaluation

A practical approach is to test both against the same repository and API contract:

Run dsh locally.
Configure the model provider you want to evaluate.
Connect both agents to the same Apidog MCP server.
Run the same implementation tasks.
Validate output with the same Apidog CLI regression suite.
Compare maintenance effort, permission behavior, cost, and developer workflow fit.

Whichever agent you choose, keep the API layer reliable with Apidog: one tested specification, available to either agent through MCP, and validated by CLI regression tests after every agent-generated change.

FAQ

Is DeepSeek Harness actually open source, unlike Claude Code?

Yes. dsh is MIT licensed, and its source is available on GitHub, including the agent loop and plugin kernel. Claude Code’s public repository uses an all-rights-reserved notice under Anthropic’s Commercial Terms and does not provide source code you can fork.

Can DeepSeek Harness use Claude models?

Yes. dsh includes catalog providers for Anthropic, OpenAI, Bedrock, Vertex, and Azure, plus custom OpenAI-compatible endpoints through settings.yaml.

The reverse is not true: Claude Code runs Claude models only, whether accessed directly through Anthropic or through Bedrock, Vertex, or Foundry.

Is DeepSeek Harness stable enough for daily work?

It is a developer preview, and the README explicitly warns about compatibility-breaking changes. You can use it for real work, but expect configuration and plugin churn.

Claude Code is the safer option for workflows you cannot afford to rebuild.

Do both agents work with Apidog?

Yes. Apidog’s MCP server exposes your API specification to MCP-capable agents:

Claude Code supports it natively.
dsh supports it through the community dsh-mcp-manager plugin.

The Apidog CLI can also run scripted regression tests from either agent’s terminal workflow. See using Apidog CLI in DeepSeek Harness.

DEV Community