1. What exactly did “tear it down and rebuild” tear down?
On October 13, 2026, Anomaly — the company behind the open-source coding tool OpenCode — formally declared version 2.0 the mainline release: from that day the official changelog lists only 2.x versions, and third-party coverage read the move as “2.0 is now OpenCode’s main release” (The New Stack, 2026-10-12/13).
Note this was not a from-zero launch. The public beta had been out for three months, and the 2.0 line shipped quietly as a separate npm package from September 11 — twenty-nine releases in thirty-two days by announcement day (Capital & Compute’s hands-on count, 2026-10-14).
The line worth quoting comes from core developer Dax Raad:
Everything in my career has to be iterated three times to get right. OpenCode 0 was the prototype, 1.x was the validation, and 2.0 is the tear-down-rebuild after thoroughly understanding this domain. — InfoQ interview, 2026-07-21
Every open-source project says something like this; few can afford the bill. The real question: what did he actually tear down? Three things, in order of how fundamental they are.
First: the API’s worldview
The official announcement blog is brutally self-critical:
The old API grew haphazardly as we and the world collectively learned what agents are and should be. It was bad. — as relayed by The New Stack, 2026-10-12/13
In plain words: the 1.x API had an editor-plugin worldview — the agent was a passive tool, waiting for an external program to drive it. The 2.0 API has an operating-system worldview — the agent is a resident process with its own session lifecycle: it can be programmed, and it can manage its own environment, creating a Git worktree, moving a session into it, and identifying and killing another session that has wedged.
In other words, what got torn down was not a pile of function signatures but the root definition of where an agent lives and who governs it. Language and framework swaps are skin and flesh; this is the bone.
Second: the tech stack
The runtime moved from Bun to Node, and the desktop shell from Tauri to Electron (InfoQ, 2026-07-21). The engineering logic is blunt:
- Bun’s performance edge could not buy Node’s ecosystem depth — plugins, corporate intranets, and long-term maintenance all stand on Node’s side, on top of the memory problems it was carrying;
- Tauri’s small binary gave way to Electron’s stability and ecosystem for the same reason.
Both are “performance romanticism” surrendering to “engineering realism” — and the earlier you surrender, the cheaper the rewrite.
Third: compatibility
The harshest one: 1.x plugins simply do not run in 2.0. Three deliberate breaking changes hit the server API and the terminal config together, and even workflows relying on LSP diagnostics had to switch to the project’s own lint and typecheck.
Looking back, the 1.x validation period actually validated three things:
- Developers want model freedom and refuse to be locked to a single vendor;
- Plugins grow new capabilities faster than any official roadmap;
- An agent’s invocation surface must be open — anyone can connect to it.
Every breaking change in 2.0 tore down a wall the validation period had proven worth tearing down.
My judgment: the rebuild was justified and necessary — the earlier you kill a semantic error in an API, the cheaper it is; wait until an ecosystem grows around the wrong API and you get Linux audio. But communication genuinely lost points: two months of silence confused the community, “is it actually stable” never got a clear label, and the Arch Linux package is still named opencode-beta. One detail I verified myself: the default npm package opencode-ai still points to 1.19.0 — the install command in most tutorials still gives you the old version, while 2.0 lives under a different package name, @opencode/cli. The company declared the transition done, but the default pipeline still carries old blood. The real cost of “iterate three times” was not the code — it was the community trust burned during those two months.
2. Side by side with Claude Code, Codex, Kimi Code, MiMoCode and DSH-TUI: the real divides are four axes
Laid out together, the biggest trap is comparing feature checklists — whose completion is faster, whose diff view is prettier. The significant divides come down to four axes: who owns the model, how open the architecture is, what the interface looks like, and how the money works.
Axis one: who owns the model
Claude Code (Anthropic) is the closed-source benchmark: Claude models only, subscription at $20–200 per month, interaction polish that is still the industry ceiling, 151,007 stars (GitHub API, 2026-10-15). Its strength and its lock are the same thing — model vertical integration bought experience and sold away choice.
Codex (OpenAI) went halfway: the CLI itself is open source (Apache-2.0), 129,364 stars (same-day count), but the service is deeply bound to ChatGPT accounts and OpenAI models — what is open is the client, not the choice.
OpenCode sits at the other pole of this axis: MIT license, bound to no model, 213,774 stars (same-day count) — the highest of the three. Its business model is strange because of it: the tool is free forever, and what you pay for is the model — its Zen gateway resells eighty-plus models at cost, pay-as-you-go, with a Go subscription from $10/month (official pricing page, checked 2026-10-15).
Axis two: where the three domestic players actually stand
(The following is supplementary research beyond the source pack.)
Kimi Code is Moonshot AI’s official terminal agent, open-sourced on May 22, 2026, running the K series models with a 256K context; officially it is a developer perk inside the Kimi membership — subscribe once and the agent comes with it. In third-party testing, Kimi K3 scored 42.0 on SWE Marathon’s long-horizon tasks, ahead of Opus-4.8’s 40.0 and GPT-5.6 Sol’s 39.0 (SegmentFault, 2026-08-12). Its position is comfortable: the most complete of the domestic model vertical integrations.
MiMoCode is Xiaomi’s fork — the official README states it is built on OpenCode, keeping all of its core capabilities (multi-provider, TUI, LSP, MCP, plugins) and adding persistent memory, sub-agent orchestration, and Compose workflows (Xiaomi’s official repo, checked 2026-10-15). It has 13,660 stars but 1,143 open issues, and early on drew complaints about “the agent uninstalling a user’s global npm packages without confirmation” (36Kr, 2026-06-11, as reported).
DSH-TUI needs a common misreading corrected first: it is not a standalone tool but the terminal-interface plugin of the DeepSeek Harness ecosystem. DSH itself is DeepSeek’s agent framework, open-sourced on August 13 under MIT, with a different architectural answer — “everything is a plugin”: a minimal Cordis core, with models, tools, sandboxes, and multi-agent coordination all mounted as plugins. It passed 160K stars in under a week, has 7,800+ ecosystem repos under the dsh-plugin topic, and DeepSeek has disclosed that roughly 60% of users run at least one third-party plugin. DSH-TUI is the terminal interface its lead officially endorsed (“built with real care since the DeepSeek Harness private beta, filling the TUI gap DSH was missing”).
Worth noting: OpenCode and DSH bet on opposite architectural answers. OpenCode bets “the agent is a resident service” — a thick core with one unified service; DSH bets “the smaller the kernel, the better” — push everything to the plugin ecosystem. Whose answer wins is an open question, but both are open source and free, which is a real win for users either way.
Axis three: the hidden line in the derivative graph
In July, Anaconda acquired Kilo, another open-source coding agent — whose CLI and VS Code extension had themselves been rebuilt on top of OpenCode (The New Stack, 2026-10-12/13). Xiaomi’s MiMoCode is an OpenCode fork.
A project being simultaneously absorbed by an acquisition chain and forked by a major Chinese vendor is a harder signal than any star count — OpenCode is becoming the “Linux kernel of the agent era”: it does not have to win outright, but nobody can route around it. It also shows what the moat in this space really is: not code secrecy (the code can be copied by anyone) but iteration speed and community trust — precisely the two things a fork cannot take with it. MiMoCode’s thousand open issues and OpenCode’s one-release-every-two-days are two snapshots of the same gap.
3. What is 2.0’s real strength: unpacking Dax’s thinking
If “thorough understanding” were a slogan, this section would not exist. Each of the four pillars answers a real problem, and together they sketch a complete operating-system-style blueprint.
Unified background service: the agent is a daemon
From 2.0, the server runs as a single resident background process; the terminal, desktop, and browser interfaces all connect to the same service — a session you opened in the terminal can be continued from the desktop app, and your own scripts auto-discover and attach to it for scheduled jobs. In OS terms, this is a daemon: the agent no longer belongs to any interface; it is a resident service on the machine, and interfaces are just skins.
Dax’s line on the official podcast is plain: “once installed it’s just there — it auto-connects on startup, everything is synced.” In 1.x, every interface ran its own agent — one body, three heads. 2.0 cut off the heads.
Code Mode: turning tool calls into programming
A lightweight JavaScript interpreter is built in, turning MCP servers and OpenAPI endpoints into programmable functions the agent can chain in a single execution. The official example: the agent pulls bug reports from GitHub, extracts the key information, and files corresponding issues in Linear — without paying a separate model round trip for each step (The New Stack, 2026-10-12/13). The official line is “add a thousand of them with minimal context bloat,” and from 2.0 this is the default mode for all MCP servers.
This one deserves a second look, because it strikes at the first-principles bottleneck of agent engineering: the more tools you attach, the more their definitions eat the context, and the dumber the agent gets. The field has basically two answers — trim the tools, or make invocation cheap. OpenCode picked the latter, and picked it radically: upgrading MCP from a “declarative manifest” into a “programmable interface.” If this step holds, the tooling ecosystem around agents scales by an order of magnitude.
Background execution: concurrency primitives
Subagents and shell commands can be thrown into the background asynchronously: delegate a code review to a subagent running a different model while the main task keeps going, with a notification when it finishes; a foreground task can be sent to the background with a shortcut. These are the concurrency primitives of an operating system — a subagent is a worker that can run a heterogeneous model. Because the tool is model-neutral, that “other model” can be anyone’s; in a closed-source tool this design is hard to even imagine — it would be sawing off your own branch.
Plugin system: the dogfood test
Eighty-plus internal plugins were restructured, covering most of 2.0’s new functionality — the company eats its own dogfood by building even its own features as plugins, which is the plugin API’s dogfood test. Hot reloading means new plugins install mid-session without a restart.
What this blueprint is betting on
Put together, Dax’s “thorough understanding” translates cleanly: in the coding-agent war, the first half was fought over whose model you connected; the second half will be fought over the agent’s runtime — process model, tool invocation, concurrency, extension mechanism. Models are becoming commodities (the same week, Anthropic cut Haiku 5.5’s price by 90% — a footnote to that trend), and the runtime is the next thing to charge for and to lock. OpenCode poured the foundation on the assumption that “the agent becomes a machine-level base service, like a database.”
Whether that judgment is right, I have no answer — the counterarguments are just as solid: the SDK is officially “still under development”; the plugin 2.0 rewrite’s fallout lands directly on the fork ecosystem (MiMoCode and friends pay the same tax); and “service-ification” is over-engineering for a single user on a single machine. But as of today, this is the most complete architectural story any coding agent has told. And the usual cold water: 213,774 is a like count, not a daily-active count; the “16M monthly developers” on the official site is self-reported; the GitHub API shows 454 named contributors against the site’s 950 — even these counters cannot agree on their own caliber.
4. The distant three or the domestic three: my lean, and four reasons
Let me state my lean up front: I lean domestic — the Kimi Code / DSH / MiMoCode side. This is not sentiment; it is arithmetic. Four reasons, the last one the hardest.
Reason one: the shape of the money
Agent costs come in three shapes:
- Subscription (Claude Code, Kimi Code’s membership bundle) — prepaying for capacity you may not exhaust;
- Pay-as-you-go (APIs, Zen) — pay for what you use, but prices ride on exchange rates and vendor moods;
- Free tiers (everyone’s Free models) — customer acquisition.
Domestic models undercut on all three: Kimi K3’s API is ¥2 per million input tokens on cache hit and ¥100 output, against GPT-6 Astra’s $10/$50 per million on Zen (SegmentFault 2026-08-12; Zen pricing page 2026-10-15) — a full order of magnitude. And note that overseas “free” is natively discounted for you: of the 13 free models on Zen, almost all are labeled “free for a limited time” as acquisition bait, and one of them, Cat Jam Free, explicitly excludes mainland China. The free list is compiled for someone else’s market, and you are not on it.
Reason two: data and keys
OpenCode’s own documentation states that OpenAI and Anthropic API requests are retained for 30 days per each provider’s policy, with models hosted in the US and EU.
The better teacher was January this year: Anthropic unilaterally barred third-party agents from using Claude Pro/Max subscription credentials, forcing a wave of developers to find exits — OpenCode’s first surge was pushed out by exactly that blockade (The New Stack, 2026-10-12/13). The lesson deserves to be carved in: use someone else’s tool and the keys live in someone else’s hand; terms can change unilaterally and your workflow gets rebuilt overnight. Domestic tool plus domestic model keeps the keys and the data path on your own side.
Reason three: the domestic side is not weak — but look honestly
DSH has the hardest ecosystem numbers — 160K stars in a week, 7,800+ ecosystem repos, 60% of users running third-party plugins; that density is first-tier globally. Its weakness is a young core, open-sourced in August.
Kimi Code is bundled with membership; its value depends entirely on whether you are already a Kimi user — if yes, it is effortless; if no, a separate subscription needs its own arithmetic.
MiMoCode is the standard specimen of the fork strategy: the dividend is starting on a 212K-star foundation; the risk is that you rebuild when the foundation renovates (when OpenCode 1.x plugins died, MiMoCode had to follow). A fork’s dividend and its contagion are the same coin.
None of the three is strongest at everything, but each stands on a real need.
Reason four: the direction of time
The hardest one. The domestic tools’ problems are problems of youth — a thousand open issues, the early package-uninstall mess. Youth heals; check again in three months and it is a different number. The overseas tools’ problems are problems of structure — vendor-bound models, geopolitical availability, functional exclusion of mainland-China users. Structure does not heal; it only worsens with geopolitics. Hand the young problems to time; hand the structural problems to the choice in your hand.
The conclusion: a division of labor, not a tribe
Let the other side be fully heard: Claude Code’s interaction polish is still unmatched, and OpenCode’s architectural story is worth stealing for everyone. So my conclusion is not either-or but a division of labor — do the daily work on a domestic agent and convert the saved subscription fees into API credit; keep your architectural eye on OpenCode, because the “agent as resident service” direction it is betting on is probably right, and whoever adopts it first profits first.
Concretely, tomorrow morning:
- Already a Kimi member: install Kimi Code — not one extra cent.
- A tinkerer who wants an ecosystem: DSH plus dsh-TUI, over a thousand plugins to pick from.
- Want a zero-cost first taste of a terminal agent: install MiMoCode, or point OpenCode at a domestic free model tier.
- Sensitive code: stay on a domestic model path — do not let a 30-day retention policy make your decisions for you.
Tool selection runs on the same logic as Dax’s method: nobody gets it right in one step; iterate three times and pick the one that understands you best at the time — and review it every three months, because in this field the right answer changes faster than you think.
Sources
- OpenCode official changelog: https://opencode.ai/changelog (checked 2026-10-15)
- OpenCode Zen pricing page: https://opencode.ai/docs/zen (checked 2026-10-15)
- The New Stack, “OpenCode 2.0 puts its terminal, desktop, and web apps on one shared service” (2026-10-12/13)
- Capital & Compute, “OpenCode 2.0: What Changed” (2026-10-14)
- InfoQ, “OpenCode’s complete rewrite at 160K stars” (2026-07-21)
- GitHub REST API measurements: anomalyco/opencode, anthropics/claude-code, openai/codex, XiaomiMiMo/MiMo-Code (2026-10-15)
- SegmentFault, “The 2026 terminal-agent era, led by Kimi Code” (2026-08-12)
- 36Kr’s early MiMoCode coverage (2026-06-11, as reported); Xiaomi MiMoCode official repo README (checked 2026-10-15)
- jiji262/awesome-deepseek-harness (2026-08-14); xmsumi on dsh-TUI (2026-10-10)
