OpenCode 2.0: The Open-Source Coding Agent Grows Up — One Background Service, Code Mode, and an SDK

What happened: a coming-of-age for the open-source coding agent

On October 12, Anomaly officially released OpenCode 2.0 (dated 2026-10-12 by AI-TLDR; covered by The New Stack on October 13). This is a major overhaul of the MIT-licensed terminal coding agent with 208K+ GitHub stars and 75+ supported model providers: from "a nice terminal tool" to "a platform."

One honest disclosure first: the 2.0.0 package on npm actually shipped back on September 11. The news here isn't "the version number appeared" — it's the official announcement going GA: 2.0 is now the mainline release, v1.19.0 stopped auto-installing updates (to make way for 2.0), and the migration guide plus SDK docs are all in place. "Trending on the homepage isn't news" — we verified against the official announcement date: October 12, inside the window.

The announcement post is modestly titled "OpenCode 2.0," but its opening line sets the tone: "a major overhaul," rebuilt on the experience of millions of daily users. Six areas changed: the Service, the API, Code Mode, Background Tasks, Plugins, and the SDK.

The Service: one background process ruling every client

OpenCode was client/server from the start, but in the 1.x era the server was mostly a power-user feature, not the default. 2.0 promotes it: the server now automatically runs as a single background process on your machine, and the terminal TUI, web interface, and desktop app all talk to the same central process.

What that means in practice: sessions, configuration, integrations, permissions, and tool execution are all unified. Close a terminal window and the agent's long-running work survives; switch interfaces and the context is still there. Two genuinely useful capabilities ship with it: the new programmatic client @opencode/client auto-discovers the local service — write a script and call it, which makes scheduled tasks trivial; and opencode pair (or /pair) exposes the service to other hosts, with native apps built on this flow "in the works."

The API: rewritten from scratch, and the agent now calls "itself"

The team is brutally honest about the old API: "The old API grew haphazardly as we and the world collectively learned what agents are and should be. It was bad."

2.0 starts over, claiming to support "nearly anything you need to be able to do." The most interesting detail: OpenCode is now aware of its own API — for example, it moves the current session into a git worktree when starting new work. The new @opencode/client package ships clients for vanilla JavaScript and Effect.

Code Mode: the real killer feature of this release

If 2.0 gets remembered for one thing, make it Code Mode. The @opencode/codemode package embeds a minimal JavaScript interpreter. It ingests MCP servers or OpenAPI endpoints and converts them into functions the agent can call inside a script — no Node.js VMs, no heavyweight solutions like QuickJS, running natively.

The effect: the agent writes a script that calls a tool, maps over the results, and calls another tool — a single round trip instead of calling tools one at a time over many turns. And the aggressive part: in 2.0, all MCP servers are opted into Code Mode by default. In the team's own words, you can add a thousand of them "with minimal context bloat," and the agent discovers and composes them to get things done.

The deeper point is worth spelling out: this turns "multi-tool calling" from a prompt-engineering problem into a code-generation problem. What are models best at? Writing code. So let them write code to call tools instead of incanting through conversations. It's a root-cause fix for the MCP ecosystem's chronic "more tools, exploding context" problem.

Background Tasks: the agent learns to idle in the background

The latest models are increasingly good at orchestration, and 2.0's harness finally keeps up with that ambition:

First, background subagents. The primary agent can hand work to another agent while it continues. Triggered automatically or manually — even with a different model. The example prompt in the announcement is vivid: "spawn a background fable subagent to review this code" while you keep prompting.

Second, background shell commands. The shell tool can be invoked asynchronously, so long-running work no longer blocks the primary agent — it gets notified on completion. If a foreground command or subagent runs longer than expected, a hotkey moves it to the background so you can keep prompting.

Plugins + SDK: 80+ internal plugins forcing the API to grow up

Version 1.0 technically had a plugin system, but the team admits "it never got the attention it needed." The 2.0 correction is hardcore: they forced themselves to implement nearly every 2.0 feature as an internal plugin — there are now 80+ of them. The Plugin API has to stay well-maintained because the team itself uses it daily. TUI plugins graduated from experimental to stable (powered by OpenTUI — "you can build nearly anything"). And everything in 2.0 hot-reloads: OpenCode can write a plugin for itself mid-session and use it right away.

@opencode/sdk turns OpenCode into a library — the exact same code that powers the CLI. Strip it down, build your own flavor, run it on a server or in specialized environments like Durable Objects, then connect from any OpenCode client (it speaks the standard OpenCode server protocol). There's also an optional Effect-based API, though the team is candid that the SDK is still in development and things will shift.

Upgrading: the breaking changes are serious

There is exactly one upgrade path: get on the latest 1.x release, then run opencode upgrade --major. The three breaking changes all bite: 1.0 plugins will not work in 2.0 and must be rewritten; the server API is completely different, so integrations calling the old API must move to @opencode/client; terminal config consolidates from layered tui.json files into a global cli.json (migrated automatically). The good news: agent, command, and skill files under .opencode/ should keep working.

Two easy-to-miss standardization signals: 2.0 discovers only AGENTS.md as its instruction file — the CLAUDE.md fallback from 1.x is gone, meaning project instruction files are converging across tools. LSP config is kept, but 2.0 no longer runs language servers or shows LSP diagnostics.

Three judgments

First, open-source agents are now playing the platform game. Background service plus rewritten API plus SDK plus plugin ecosystem — that's a full platform play. Compare the trajectories: Claude Code and Codex bet on deep model-tool integration behind closed doors; OpenCode bets on openness — 75+ model providers, bring-your-own-key, MIT license. Neither bet is wrong, but a 208K-star project choosing platformization says the AI coding-tool competition has entered its second half: it's no longer about completion quality, it's about workflow infrastructure.

Second, Code Mode may define the next generation of agent harnesses. Once "let the model write code to call tools" works reliably, the number of MCP servers stops being a liability. Note that line about "a thousand MCP servers" — it's not rhetoric, it's an architectural declaration: tool discovery and composition should happen in code, not by stuffing every tool description into the prompt.

Third, the practical meaning for vibe coders. If you use OpenCode: read the migration guide before upgrading a machine you depend on — plugin users especially should budget time for rewrites. If you haven't picked a tool: the Go subscription is $10/month (Plus $40), Zen is pay-as-you-go from a $20 balance, and with 75+ providers plus BYOK, the billing leverage is yours. And AGENTS.md convergence means the instruction files you write for your projects are becoming cross-tool assets.