DeepSeek Harness vs OpenCode: Which One We Run in 2026

We added OpenCode to Helix on 13 August 2026, the day DeepSeek released its harness, and DeepSeek Harness six days later. A month on, OpenCode drives the open-weight models on our own hardware, and Helix clients run it inside their own agents. DeepSeek Harness, the fastest repository to 200,000 GitHub stars by Star History’s count, is still an experiment in our fleet. The stars and the work have gone to different tools.

OpenCode is Anomaly’s open-source, MIT-licensed coding agent that runs in a terminal, browser, desktop app or IDE against more than 75 model providers. DeepSeek Harness is DeepSeek’s MIT-licensed agent runtime, in developer preview since 13 August 2026, where the loop, the tools and the interface are all plugins. OpenCode does more as a harness, and DeepSeek Harness comes with a sandbox. If a sandbox already sits round your agents, as one does round ours in Helix, choose OpenCode. If not, DeepSeek Harness gives you both in one tool.

Side by side, with the versions we checked

We checked both on 20 September 2026: OpenCode at 2.0.11, published that morning, and DeepSeek Harness at v0.1.6-alpha.2. Every cell describes those two versions.

OpenCode 2.0 arrived quietly. Its 2.0 line has been on npm as @opencode/cli since 11 September 2026, twelve releases in nine days, while the original opencode-ai package still serves 1.18.31 as its latest and Anomaly has published no release notes and no changelog entry for the 2.0 line. Every row below describes 2.0, and each one also held on the 1.x line when we checked it.

Both run as sandboxed desktops in our Helix fleet, which is where the last column comes from. We have not run the two against each other on the same task, so every number below is somebody else’s, named where it appears.

Where each one puts its extension points

OpenCode looks like a terminal app, but the terminal is one client of many. Running opencode starts a server and a terminal interface that talks to it, and the browser, desktop and editor front ends are clients of the same API. Plugins hook into sessions, messages, permissions and every tool call, and tool.execute.before and tool.execute.after can rewrite a call or block it. An agent is a markdown or JSON file with its own model, prompt, permissions and tool access, and a primary agent can call sub-agents. That markdown-agent pattern is the one we describe in our guide to how to build AI agents.

DeepSeek Harness goes a layer below. Plugins provide every agent capability, in DeepSeek’s words “including models, tools, skills, sessions, sandboxes, storage, loops, scheduling, and the UI”. That list includes the loop that decides what the agent does next, so you can replace the loop itself. OpenCode gives you hooks around the loop. DeepSeek Harness gives you the loop.

DeepSeek Harness can also drive other agents. First-party plugins run Claude Code and Codex as its sub-agents, both off by default, both running through the Claude Agent SDK or the Codex app-server on your own login. On the Agent Client Protocol, OpenCode is ahead: it ships opencode acp and sits in Zed’s registry, while dsh-acp is automation-only, so driving DeepSeek Harness from Zed relies on third-party plugins.

So is OpenCode a harness? It is, even though Anomaly calls it “the open source AI coding agent”. A harness is the code around a model that turns it into an agent that acts: the loop that keeps calling the model, the tools it may run, the sandbox those tools run in, and the rules that decide what reaches the context window. LangChain draws the line in three places, a framework such as LangChain, a runtime such as LangGraph and a harness such as its own DeepAgents, and Harrison Chase concedes the lines are blurry. Birgitta Böckeler uses the word for what you build around a coding agent yourself, which is the part a team has to add.

What the token gap costs

Composio has run the two side by side on the same model. On DeepSeek V4 Pro, across 30 tool-use tasks on 31 August 2026, with OpenCode then on its 1.x line, DeepSeek Harness passed 20 and OpenCode 19. OpenCode used about eight times as many tokens per task, 710,140 against 88,562, yet cost $0.032 per success against DeepSeek Harness’s $0.028. Eight times the tokens cost only 14% more on that model, because DeepSeek bills cached input at a few percent of the uncached rate. You can cache prompts yourself. vLLM caches prompt prefixes automatically, SGLang reuses the KV cache through RadixAttention, and we turn it on for Qwen on our own hardware. DeepSeek discounts cached input. Other hosted APIs charge full price for it, and against those the same gap in tokens is a real gap in price.

That is one run: 30 tool-use tasks, one model, one date. A coding job in a repository may land differently, and Composio warns that each harness counts tokens differently.

Re-read history and loop steps fill the context more than the system prompt does. AtlasCloud’s comparison of DeepSeek Harness with Hermes, in August 2026, measured it: DeepSeek Harness’s system prompt is 10,898 tokens and Hermes’ about 3,000 more, cached history makes up 88.8% and 95.5% of their prompt tokens, and DeepSeek Harness made 8 tool calls against Hermes’ 35. On base overhead alone, OpenCode sends about 7,000 tokens before your prompt against Claude Code’s 33,000, by Developers Digest’s count in July 2026.

Model prices differ far more than harnesses do. At September 2026 list prices, DeepSeek V4 Flash output costs $0.60 per million tokens off-peak and Claude Opus 5 output $25 per million, about forty times dearer. Inside DeepSeek Harness alone, Pro costs fourteen times more per output token than Flash on DeepInfra, and in Verdent’s comparison the per-task cost across models runs 8.6x, from $0.32 on GLM-5.2 to $2.75 on Fable 5. Choose the model first, then the harness.

Running them against models on your own hardware

Our own choice, for now, is GLM 5.3 for coding and Qwen 3.8 for everything else, both on our own hardware and both under OpenCode. That changes almost daily as new open weights land, which is why the harness should stay out of the model decision.

Qwen 3.8 shows what a model does to a harness. It is chatty. Small models get reinforced to think at length because it lifts their benchmark scores, and the cost arrives as excessive tool calls, verbose descriptions and slow replies, so the agent feels slow whatever harness runs it. Qwen 3.8 is fine for small ad hoc agentic jobs, and I would not hand it our code. It is also a vision model, which helps a lot with frontend work. I would like the next models tuned for how fast they finish a job as well as whether they finish it.

DeepSeek Harness gives something up here, because it is tailored to DeepSeek’s own models. They are its default: the setup guide starts with a DeepSeek API key, and V4 Pro and V4 Flash run with thinking switched on. The coupling buys deep integration between DeepSeek’s models and the harness’s own features. A general-purpose harness such as OpenCode forgoes that in exchange for 75-plus providers.

Below the harness sits the serving stack, with its own decisions. vLLM and SGLang each offer a smorgasbord of options for tuning performance, prompt caching among them, and a routing layer can sit above them: Helix’s ramjet routes requests across multi-model hardware. None of that is the harness’s business.

Whether a self-hosted setup works at all depends less on any of those layers than on context. The agent needs the right data at the right time, and bad context and bad prompts cause more of the failures we see than the harness or the model does. The model still has to fit the task, and a task too complicated for the model fails whichever harness runs it. Fitting the model to the task is work we do. We deploy open-weight models such as Qwen, Llama and Mistral on client infrastructure, air-gapped where the data demands it, and fine-tune and quantise smaller ones when a general model is too slow or too expensive for the job. That is our LLM consulting practice.

Self-hosting costs you convenience. A hosted frontier model is one API key and somebody else’s uptime. Ours is a machine, a serving stack, a routing layer and a model that changes underneath us. The failure peculiar to local setups is a tool-call format one agent emits that another model or server cannot parse. Qwen 3.8 under OpenCode avoided it: its tool calls worked, and it simply talked too much.

Where containment belongs

Running agents on your own hardware also means containing them yourself. A sandbox is the enclave an agent is allowed to work inside, and how much of one you need depends on the job. Sometimes a permission model is enough. Where the environment has to be secure, the harness is one layer among several, with a container or a hypervisor around it, or capability-based tools that give stronger guarantees than a yes-or-no prompt.

The two tools put that layer in different places, on purpose. OpenCode asks permission, with rules that allow, deny or ask before a tool runs, and leaves containment to whatever runs the agent. DeepSeek Harness builds it in, with bubblewrap or Landlock on Linux and Seatbelt on macOS, starting read-only until you widen it, alongside a local credentials file and an append-only session log you can replay and fork. Its own safety notes put the limit plainly: sandboxing reduces risk and does not guarantee isolation, whichever tool provides it.

A team whose agents share one codebase needs more than either tool gives: a separate machine per agent, separate credentials, and a record that somebody other than the developer who ran it can read. The failures containment cannot catch, from tool misuse to runaway loops, are in our write-up of why AI agents fail in production.

Where the harness stops and the team starts

Helix works at that layer. Every Helix thread boots a containerised Ubuntu desktop on your own infrastructure, with an IDE, a terminal, a browser and the repository cloned onto its own branch: one thread, one branch, one isolated desktop. Helix has run OpenCode since release 2.12.3 and DeepSeek Harness since 2.12.4, alongside Claude Code, Codex, Gemini CLI, Qwen Code, Goose and Zed Agent. Clients run OpenCode there in their own agents. DeepSeek Harness runs in our own fleet only. Helix is co-developed by the Winder.AI team, and I am one of its co-founders.

Inside that platform, the harness is a personal choice. Every developer has opinions about how they want to work, and they are rarely the same opinions. We also work collaboratively, so shared agents matter to us as much as personal ones, and the jobs differ: some of our agent use is coding, on Helix itself and on other applications, and the rest is back-office and client work. A harness, a model and a sandbox have to fit the person and the task, and every combination has its costs.

When a client team adopts a harness, the harness is the small decision. Our AI agent development services cover the rest: agent architecture, custom agents with evaluation harnesses and guardrails, and the observability, retries and fallbacks that production demands. The audit logging and controls a regulated team needs sit in our AI governance work. Whichever harness a team lands on, an evaluation suite is what tells them the choice was right. We set out how we build one in our guide to testing an agent before you ship it, and published a working agent with its evaluation suite and committed results to check it against.

Which layer you need is the bigger question, and our comparison of AI agent harnesses works through the model, harness, framework and platform decision in full. If you want it walked through against your own stack, get in touch.

Which one to install

Choose OpenCode if:

• you want 75-plus model providers, including models on hardware you own;
• you work in a terminal and want browser, desktop, IDE and ACP clients as well;
• you can live with a line that ships most days;
• containment already sits in the layer around your agents, or you can put it there.

Choose DeepSeek Harness if:

• you want to replace the agent loop itself;
• you want a sandbox built in, read-only until you widen it;
• you run DeepSeek’s models, where cached pricing shrinks the token gap;
• you want Claude Code or Codex driven as sub-agents on your own logins.

Run both if your team has people who want each. Standardise on the platform around them, and let each developer pick the harness.

If DeepSeek Harness is the wrong fit, Composio’s earlier run names the alternatives worth trying. On 11 August 2026, two days before DeepSeek Harness shipped, Composio put eight harnesses through the same 30 tasks on DeepSeek V4 Flash. In that run, tokens per task ranged from about 192,000 for Hermes to 1.4 million for Prime Agent, cost per success ran from $0.028 for Pi to $0.195 for Claude Code, and OpenCode, then on 1.x, passed 46.7% of tasks at about 692,000 tokens each.

OpenCode 2.0 reached npm on 11 September 2026 with no release notes and no changelog entry, under a new package name. It drives our coding against open-weight models on our own hardware anyway, and DeepSeek Harness stays in the fleet, because a loop you can replace is worth watching even while nothing about it is stable.